@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,1985 @@
+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 { 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 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",
+    "Priority",
+    "Source",
+    "Endpoint/Field",
+    "Dimension",
+    "Rule",
+    "Required Test Points",
+    "Case IDs",
+    "Status",
+];
+const CASE_SECTION_ALIASES = {
+    acceptance: ["验收标准", "Acceptance Criteria"],
+    rules: ["覆盖规则", "Coverage Rules"],
+    testPoints: ["测试点", "Test Points"],
+    scenarioTypes: ["场景类型", "Scenario Types", "Scenario Type"],
+    automation: ["自动化映射", "自动化说明", "Automation Notes"],
+};
+const TEST_POINT_BINDING_MODES = ["variant", "assertion", "cross-cutting"];
+const CHANGE_CLASSIFICATIONS = [
+    "new-operation",
+    "contract-change",
+    "behavior-change",
+    "bugfix",
+    "implementation-optimization",
+];
+const COVERAGE_POLICIES = [
+    "full-contract",
+    "affected-contract-full",
+    "affected-behavior-full",
+    "reproduction-plus-neighbors",
+    "change-focused-plus-regression-floor",
+];
+const COVERAGE_POLICY_BY_CLASSIFICATION = {
+    "new-operation": "full-contract",
+    "contract-change": "affected-contract-full",
+    "behavior-change": "affected-behavior-full",
+    bugfix: "reproduction-plus-neighbors",
+    "implementation-optimization": "change-focused-plus-regression-floor",
+};
+const REQUIRED_REGRESSION_FLOOR = {
+    "new-operation": [],
+    "contract-change": ["main-success-path", "unchanged-response-shape", "changed-contract-boundaries"],
+    "behavior-change": ["main-success-path", "unchanged-response-shape", "affected-state-transition"],
+    bugfix: ["main-success-path", "unchanged-response-shape", "defect-reproduction", "adjacent-boundary"],
+    "implementation-optimization": ["main-success-path", "unchanged-response-shape"],
+};
+const AUTOMATION_BINDING_LABELS = {
+    variant: ["变体测试点", "Variant Test Points"],
+    assertion: ["场景断言测试点", "Assertion Test Points"],
+    "cross-cutting": ["横切证据测试点", "Cross-Cutting Test Points"],
+};
+const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+const inputFileSchema = z.object({ path: z.string().min(1), sha256: sha256Schema }).strict();
+const sourceBindingSchema = z.object({
+    taskId: z.string().min(1),
+    requirementPath: z.string().min(1),
+    requirementSha256: sha256Schema,
+    referencePaths: z.array(z.string().min(1)),
+    requirementIds: z.array(z.string().min(1)),
+}).strict();
+const coverageCaseSchema = z.object({
+    caseId: z.string().min(1),
+    title: z.string().min(1),
+    markdownPath: z.string().min(1),
+    acIds: z.array(z.string()),
+    ruleKeys: z.array(z.string()),
+    testPoints: z.array(z.string()),
+    testPointBindings: z.array(z.object({
+        testPoint: z.string(),
+        mode: z.enum(TEST_POINT_BINDING_MODES),
+    }).strict()),
+    unclassifiedTestPoints: z.array(z.string()),
+    duplicateBindingTestPoints: z.array(z.string()),
+    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),
+    priority: z.enum(["P0", "P1", "P2"]),
+    source: z.string().min(1),
+    endpointField: z.string().min(1),
+    dimension: z.string().min(1),
+    rule: z.string().min(1),
+    requiredTestPoints: z.array(z.string()),
+    caseIds: z.array(z.string()),
+    declaredStatus: z.enum(["COVERED", "PARTIAL", "GAP", "CONFLICT"]),
+    coveredTestPoints: z.array(z.string()),
+    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),
+    affectedOperations: z.array(z.string().min(1)),
+    affectedRuleKeys: z.array(z.string().min(1)),
+    regressionFloor: z.array(z.string().min(1)),
+    scopeEvidence: z.array(z.string().min(1)),
+    completenessClaim: z.enum(["affected-operations-full", "affected-scope"]),
+}).strict();
+export const backendTestCaseCoverageFactsSchema = z.object({
+    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),
+        ruleCount: z.number().int().min(0),
+        coveredRuleCount: z.number().int().min(0),
+        testPointCount: z.number().int().min(0),
+        coveredTestPointCount: z.number().int().min(0),
+        enumValueCount: z.number().int().min(0),
+        coveredEnumValueCount: z.number().int().min(0),
+        invalidEquivalenceClassCount: z.number().int().min(0),
+        coveredInvalidEquivalenceClassCount: z.number().int().min(0),
+        boundaryPointCount: z.number().int().min(0),
+        coveredBoundaryPointCount: z.number().int().min(0),
+        formatClassCount: z.number().int().min(0),
+        coveredFormatClassCount: z.number().int().min(0),
+        businessStateCount: z.number().int().min(0),
+        coveredBusinessStateCount: z.number().int().min(0),
+        gapCount: z.number().int().min(0),
+        conflictCount: z.number().int().min(0),
+        variantTestPointCount: z.number().int().min(0),
+        assertionTestPointCount: z.number().int().min(0),
+        crossCuttingTestPointCount: z.number().int().min(0),
+        unclassifiedTestPointCount: z.number().int().min(0),
+        duplicateBindingTestPointCount: z.number().int().min(0),
+    }).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()),
+}).strict();
+const correspondenceEntrySchema = z.object({
+    markdownModule: z.string().min(1),
+    caseId: z.string().optional(),
+    testPoints: z.array(z.string()),
+    variantTestPoints: z.array(z.string()),
+    assertionTestPoints: z.array(z.string()),
+    crossCuttingTestPoints: z.array(z.string()),
+    mappedTestPoints: z.array(z.string()),
+    declaredScript: z.string().optional(),
+    declaredPrimarySymbol: z.string().optional(),
+    expectedScript: z.string().min(1),
+    actualScripts: z.array(z.string()),
+    pytestSymbols: z.array(z.string()),
+    parameterIds: z.array(z.string()),
+    cardinality: z.enum(["1:1", "1:0", "1:N", "0:1"]),
+    status: z.enum([
+        "EXACT_1_TO_1",
+        "MISSING_PYTEST",
+        "MULTIPLE_PYTEST",
+        "EXTRA_PYTEST",
+        "SCRIPT_MISMATCH",
+        "SYMBOL_MISSING_CASE_ID",
+        "VARIANT_PARAMETER_MISSING",
+        "ASSERTION_BINDING_MISSING",
+        "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-v3"),
+    schemaVersion: z.literal(3),
+    taskId: z.string().min(1),
+    status: z.enum(["PASS", "FAIL", "UNAVAILABLE"]),
+    inputFiles: z.array(inputFileSchema),
+    summary: z.object({
+        markdownModuleCount: z.number().int().min(0),
+        exactModuleCount: z.number().int().min(0),
+        markdownCaseCount: z.number().int().min(0),
+        exactCorrespondenceCount: z.number().int().min(0),
+        primarySymbolCount: z.number().int().min(0),
+        missingPytestCount: z.number().int().min(0),
+        multiplePytestCount: z.number().int().min(0),
+        extraPytestCount: z.number().int().min(0),
+        scriptMismatchCount: z.number().int().min(0),
+        testPointCount: z.number().int().min(0),
+        mappedTestPointCount: z.number().int().min(0),
+        variantTestPointCount: z.number().int().min(0),
+        assertionTestPointCount: z.number().int().min(0),
+        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()),
+}).strict();
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function openApiToken(value) {
+    return value.replace(/[{}]/g, "").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toUpperCase();
+}
+function resolveOpenApiSchema(document, value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.$ref !== "string" || !value.$ref.startsWith("#/"))
+        return value;
+    let current = document;
+    for (const segment of value.$ref.slice(2).split("/")) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+    }
+    return isRecord(current) ? current : undefined;
+}
+function openApiTestPoints(field, dimension, values = []) {
+    const prefix = `TP-${openApiToken(field)}`;
+    if (dimension === "enum")
+        return [...values.map((value) => `${prefix}-ENUM-${openApiToken(value)}`), `${prefix}-ENUM-UNKNOWN`, `${prefix}-ENUM-CASE-VARIANT`, `${prefix}-ENUM-WHITESPACE`, `${prefix}-ENUM-EMPTY`, `${prefix}-ENUM-NULL`, `${prefix}-ENUM-WRONG-TYPE`];
+    if (dimension === "boundary")
+        return [`${prefix}-MIN-1`, `${prefix}-MIN`, `${prefix}-NOMINAL`, `${prefix}-MAX`, `${prefix}-MAX-PLUS-1`];
+    if (dimension === "format")
+        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;
+    const normalized = sourcePath.replaceAll("\\", "/").replace(/^\.\//, "");
+    const boundPrefix = `.harness/tasks/${taskId}/`;
+    return normalized.startsWith(boundPrefix)
+        ? path.join(workspaceRoot, ...normalized.split("/"))
+        : path.join(workspaceRoot, ".harness", "tasks", taskId, ...normalized.split("/"));
+}
+export async function extractBackendTestOpenApiRules(input) {
+    const rules = [];
+    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;
+            for (const method of ["get", "post", "put", "patch", "delete"]) {
+                const operation = pathItem[method];
+                if (!isRecord(operation))
+                    continue;
+                const operationBase = `API-${method.toUpperCase()}-${openApiToken(apiPath)}`;
+                const responses = isRecord(operation.responses) ? operation.responses : {};
+                const responseStatuses = Object.keys(responses).filter((status) => /^(?:[1-5]\d\d|default)$/i.test(status)).sort();
+                if (responseStatuses.length > 0) {
+                    rules.push({
+                        ruleKey: `${operationBase}-RESPONSE-STATUS`,
+                        priority: "P1",
+                        source: referencePath,
+                        endpointField: `${method.toUpperCase()} ${apiPath} / response status`,
+                        dimension: "response-status",
+                        rule: `documented response statuses: ${responseStatuses.join(", ")}`,
+                        requiredTestPoints: responseStatuses.map((status) => `TP-RESPONSE-STATUS-${openApiToken(status)}`),
+                    });
+                }
+                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 field = parameter.name;
+                    const property = resolveOpenApiSchema(document, parameter.schema);
+                    if (!property)
+                        continue;
+                    const base = `${operationBase}-${openApiToken(field)}`;
+                    const endpointField = `${method.toUpperCase()} ${apiPath} / ${String(parameter.in ?? "parameter")}:${field}`;
+                    const add = (suffix, dimension, rule, points = openApiTestPoints(field, dimension)) => {
+                        rules.push({ ruleKey: `${base}-${suffix}`, priority: "P1", source: referencePath, endpointField, dimension, rule, requiredTestPoints: points });
+                    };
+                    if (parameter.required === true)
+                        add("REQUIRED", "requiredness", `${field} parameter is required`);
+                    if (Array.isArray(property.enum)) {
+                        const values = property.enum.map(String);
+                        add("ENUM", "enum", `${field} enum: ${values.join(", ")}`, openApiTestPoints(field, "enum", values));
+                    }
+                    const boundaryPoints = openApiTestPoints(field, "boundary");
+                    if (typeof property.minimum === "number")
+                        add("MINIMUM", "boundary", `${field} minimum=${property.minimum}`, boundaryPoints.filter((point) => !point.includes("MAX")));
+                    if (typeof property.maximum === "number")
+                        add("MAXIMUM", "boundary", `${field} maximum=${property.maximum}`, boundaryPoints.filter((point) => !point.includes("MIN-")));
+                    if (typeof property.pattern === "string")
+                        add("PATTERN", "format", `${field} pattern=${property.pattern}`);
+                    if (typeof property.format === "string")
+                        add("FORMAT", "format", `${field} format=${property.format}`);
+                }
+                const requestBody = isRecord(operation.requestBody) ? operation.requestBody : undefined;
+                const content = requestBody && isRecord(requestBody.content) ? requestBody.content : undefined;
+                const media = content && (content["application/json"] ?? Object.values(content)[0]);
+                const schema = resolveOpenApiSchema(document, isRecord(media) ? media.schema : undefined);
+                if (!schema)
+                    continue;
+                const required = new Set(Array.isArray(schema.required) ? schema.required.filter((value) => typeof value === "string") : []);
+                const properties = isRecord(schema.properties) ? schema.properties : {};
+                for (const [field, rawProperty] of Object.entries(properties)) {
+                    const property = resolveOpenApiSchema(document, rawProperty);
+                    if (!property)
+                        continue;
+                    const base = `${operationBase}-${openApiToken(field)}`;
+                    const endpointField = `${method.toUpperCase()} ${apiPath} / ${field}`;
+                    const add = (suffix, dimension, rule, points = openApiTestPoints(field, dimension)) => {
+                        rules.push({ ruleKey: `${base}-${suffix}`, priority: "P1", source: referencePath, endpointField, dimension, rule, requiredTestPoints: points });
+                    };
+                    if (required.has(field))
+                        add("REQUIRED", "requiredness", `${field} is required`);
+                    if (Array.isArray(property.enum)) {
+                        const values = property.enum.map(String);
+                        add("ENUM", "enum", `${field} enum: ${values.join(", ")}`, openApiTestPoints(field, "enum", values));
+                    }
+                    const boundaryPoints = openApiTestPoints(field, "boundary");
+                    if (typeof property.minLength === "number")
+                        add("MIN-LENGTH", "boundary", `${field} minLength=${property.minLength}`, boundaryPoints.filter((point) => !point.includes("MAX")));
+                    if (typeof property.maxLength === "number")
+                        add("MAX-LENGTH", "boundary", `${field} maxLength=${property.maxLength}`, boundaryPoints.filter((point) => !point.includes("MIN-")));
+                    if (typeof property.minimum === "number")
+                        add("MINIMUM", "boundary", `${field} minimum=${property.minimum}`, boundaryPoints.filter((point) => !point.includes("MAX")));
+                    if (typeof property.maximum === "number")
+                        add("MAXIMUM", "boundary", `${field} maximum=${property.maximum}`, boundaryPoints.filter((point) => !point.includes("MIN-")));
+                    if (typeof property.pattern === "string")
+                        add("PATTERN", "format", `${field} pattern=${property.pattern}`);
+                    if (typeof property.format === "string")
+                        add("FORMAT", "format", `${field} format=${property.format}`);
+                }
+            }
+        }
+    }
+    return rules.sort((left, right) => left.ruleKey.localeCompare(right.ruleKey));
+}
+function orderedUnique(values) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (!value || seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+function canonicalCaseId(value) {
+    const upper = value.toUpperCase().replaceAll("_", "-").replace(/-+/g, "-");
+    return /^(BE-[A-Z0-9]+(?:-[A-Z0-9]+)*)-\d{3}$/.test(upper) ? upper : value.toUpperCase();
+}
+function caseIds(value) {
+    return orderedUnique((value.match(CASE_ID_IN_TEXT) ?? []).map(canonicalCaseId));
+}
+function sectionBody(body, aliases) {
+    const escaped = aliases.map((value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    const marker = new RegExp(`^###\\s+(?:${escaped})\\s*$`, "mi");
+    const match = marker.exec(body);
+    if (!match)
+        return "";
+    const rest = body.slice(match.index + match[0].length);
+    const next = /^###\s+/m.exec(rest);
+    return rest.slice(0, next?.index ?? rest.length);
+}
+function listTokens(body, aliases, pattern) {
+    const section = sectionBody(body, aliases).replaceAll("`", "");
+    // 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)
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^\s*(?:[-*+] |\d+[.)]\s*)/, "").replaceAll("`", "").trim())
+        .flatMap((line) => line.split(/[;,，、]/).map((item) => item.trim().toLowerCase()))
+        .filter(Boolean));
+}
+function declaredScripts(body) {
+    const automation = sectionBody(body, CASE_SECTION_ALIASES.automation);
+    return orderedUnique([...automation.matchAll(/testcase\/[A-Za-z0-9_./-]*test_[A-Za-z0-9_.-]*\.py/gi)]
+        .map((match) => match[0].replaceAll("\\", "/")));
+}
+function automationLabelBody(body, labels) {
+    const automation = sectionBody(body, CASE_SECTION_ALIASES.automation);
+    const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    const match = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:]\\s*(.*)$`, "mi").exec(automation);
+    return match?.[1]?.replaceAll("`", "").trim() ?? "";
+}
+function testPointBindingFacts(body, testPoints) {
+    const bindings = TEST_POINT_BINDING_MODES.flatMap((mode) => {
+        const value = automationLabelBody(body, AUTOMATION_BINDING_LABELS[mode]);
+        return orderedUnique(value.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? [])
+            .map((testPoint) => ({ testPoint, mode }));
+    });
+    const counts = new Map();
+    for (const binding of bindings)
+        counts.set(binding.testPoint, (counts.get(binding.testPoint) ?? 0) + 1);
+    return {
+        testPointBindings: bindings,
+        unclassifiedTestPoints: testPoints.filter((testPoint) => !counts.has(testPoint)),
+        duplicateBindingTestPoints: testPoints.filter((testPoint) => (counts.get(testPoint) ?? 0) > 1),
+    };
+}
+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;
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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, layout) {
+    const result = [];
+    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) {
+            const heading = headings[index];
+            const id = canonicalCaseId(heading[1]);
+            const body = markdown.slice(heading.index, headings[index + 1]?.index ?? markdown.length);
+            const testPoints = listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT);
+            result.push({
+                caseId: id,
+                title: cleanTitle(heading[0], id),
+                markdownPath: path.relative(workspaceRoot, file).replaceAll(path.sep, "/"),
+                acIds: orderedUnique(body.match(AC_ID_IN_TEXT) ?? []),
+                ruleKeys: listTokens(body, CASE_SECTION_ALIASES.rules, RULE_KEY),
+                testPoints,
+                ...testPointBindingFacts(body, testPoints),
+                scenarioTypes: scenarioTypes(body),
+                declaredScripts: declaredScripts(body),
+                declaredPrimarySymbols: declaredPrimarySymbols(body),
+                payloadContract: payloadContract(body),
+                body,
+            });
+        }
+    }
+    return result;
+}
+function parseTableRow(line) {
+    const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+    const cells = [];
+    let current = "";
+    for (let index = 0; index < trimmed.length; index += 1) {
+        const char = trimmed[index];
+        if (char === "\\" && trimmed[index + 1] === "|") {
+            current += "|";
+            index += 1;
+        }
+        else if (char === "|") {
+            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;
+        }
+    }
+    cells.push(current.trim());
+    return cells;
+}
+function splitCellTokens(value, pattern) {
+    const values = orderedUnique(value.split(/;|<br\s*\/?\s*>|，|、/i).map((item) => item.replaceAll("`", "").trim()).filter(Boolean));
+    return pattern ? values.filter((item) => pattern.test(item)) : values;
+}
+function parseCoverageScope(readme) {
+    const findings = [];
+    const fallback = {
+        changeClassification: "new-operation",
+        coveragePolicy: "full-contract",
+        affectedOperations: [],
+        affectedRuleKeys: [],
+        regressionFloor: [],
+        scopeEvidence: [],
+        completenessClaim: "affected-operations-full",
+    };
+    const marker = /^##\s+Coverage Scope\s*$/mi.exec(readme);
+    if (!marker)
+        return { scope: fallback, findings: ["README is missing required ## Coverage Scope section; defaulted to full-contract"] };
+    const rest = readme.slice(marker.index + marker[0].length);
+    const nextHeading = /^##\s+/m.exec(rest);
+    const section = rest.slice(0, nextHeading?.index ?? rest.length);
+    const lines = section.split(/\r?\n/).filter((line) => line.trim().startsWith("|"));
+    if (lines.length < 2 || JSON.stringify(parseTableRow(lines[0])) !== JSON.stringify(["Field", "Value"])) {
+        return { scope: fallback, findings: ["Coverage Scope table headers must be exactly: Field | Value"] };
+    }
+    const separatorCells = lines[1] ? parseTableRow(lines[1]) : [];
+    const hasSeparator = separatorCells.length === 2 && separatorCells.every((cell) => /^:?-{3,}:?$/.test(cell));
+    if (!hasSeparator)
+        findings.push("Coverage Scope table is missing the required |---|---| separator row");
+    const values = new Map();
+    for (const line of lines.slice(hasSeparator ? 2 : 1)) {
+        const cells = parseTableRow(line);
+        if (cells.length !== 2) {
+            findings.push(`Coverage Scope row must have exactly 2 columns: ${line.slice(0, 160)}`);
+            continue;
+        }
+        const field = cells[0].trim();
+        if (values.has(field))
+            findings.push(`duplicate Coverage Scope field: ${field}`);
+        values.set(field, cells[1].trim());
+    }
+    const classificationRaw = (values.get("Change Classification") ?? "").replaceAll("`", "").trim();
+    const policyRaw = (values.get("Coverage Policy") ?? "").replaceAll("`", "").trim();
+    const changeClassification = CHANGE_CLASSIFICATIONS.includes(classificationRaw)
+        ? classificationRaw
+        : fallback.changeClassification;
+    const coveragePolicy = COVERAGE_POLICIES.includes(policyRaw)
+        ? policyRaw
+        : fallback.coveragePolicy;
+    if (!CHANGE_CLASSIFICATIONS.includes(classificationRaw))
+        findings.push(`invalid or missing Change Classification: ${classificationRaw || "<empty>"}`);
+    if (!COVERAGE_POLICIES.includes(policyRaw))
+        findings.push(`invalid or missing Coverage Policy: ${policyRaw || "<empty>"}`);
+    const expectedPolicy = COVERAGE_POLICY_BY_CLASSIFICATION[changeClassification];
+    if (coveragePolicy !== expectedPolicy)
+        findings.push(`Change Classification ${changeClassification} requires Coverage Policy ${expectedPolicy}, received ${coveragePolicy}`);
+    const affectedOperations = splitCellTokens(values.get("Affected Operations") ?? "").map((value) => value.replace(/\s+/g, " ").trim());
+    const affectedRuleKeys = splitCellTokens(values.get("Affected Rule Keys") ?? "", RULE_KEY);
+    const regressionFloor = splitCellTokens(values.get("Regression Floor") ?? "").map((value) => value.toLowerCase());
+    const scopeEvidence = splitCellTokens(values.get("Scope Evidence") ?? "");
+    if (affectedOperations.length === 0)
+        findings.push("Coverage Scope requires at least one Affected Operations entry");
+    if (affectedRuleKeys.length === 0)
+        findings.push("Coverage Scope requires at least one Affected Rule Keys entry");
+    if (scopeEvidence.length === 0)
+        findings.push("Coverage Scope requires non-empty Scope Evidence");
+    for (const required of REQUIRED_REGRESSION_FLOOR[changeClassification]) {
+        if (!regressionFloor.includes(required))
+            findings.push(`Coverage Scope regression floor is missing required entry: ${required}`);
+    }
+    return {
+        scope: {
+            changeClassification,
+            coveragePolicy,
+            affectedOperations,
+            affectedRuleKeys,
+            regressionFloor,
+            scopeEvidence,
+            completenessClaim: coveragePolicy === "full-contract" ? "affected-operations-full" : "affected-scope",
+        },
+        findings,
+    };
+}
+function operationFromEndpointField(endpointField) {
+    const match = /^([A-Z]+)\s+(\/\S+)/.exec(endpointField.trim());
+    return match ? `${match[1]} ${match[2]}` : undefined;
+}
+function parseCoverageMatrix(readme) {
+    const findings = [];
+    const marker = /^##\s+(?:(?:\d+(?:\.\d+)*[.)]?\s+)?(?:Coverage Matrix|覆盖矩阵))\s*$/mi.exec(readme);
+    if (!marker)
+        return { rows: [], findings: ["README is missing required ## Coverage Matrix section"] };
+    if (!/^##\s+Coverage Matrix\s*$/i.test(marker[0])) {
+        findings.push(`Coverage Matrix should use the exact canonical heading \"## Coverage Matrix\"; accepted compatibility heading: ${marker[0].trim()}`);
+    }
+    const rest = readme.slice(marker.index + marker[0].length);
+    const nextHeading = /^##\s+/m.exec(rest);
+    const section = rest.slice(0, nextHeading?.index ?? rest.length);
+    const lines = section.split(/\r?\n/).filter((line) => line.trim().startsWith("|"));
+    if (lines.length < 2)
+        return { rows: [], findings: ["Coverage Matrix table is missing or incomplete"] };
+    const headers = parseTableRow(lines[0]);
+    if (JSON.stringify(headers) !== JSON.stringify(COVERAGE_HEADERS)) {
+        findings.push(`Coverage Matrix headers must be exactly: ${COVERAGE_HEADERS.join(" | ")}`);
+        return { rows: [], findings };
+    }
+    const rows = [];
+    for (const line of lines.slice(2)) {
+        const cells = parseTableRow(line);
+        if (cells.length !== COVERAGE_HEADERS.length) {
+            findings.push(`Coverage Matrix row has ${cells.length} columns instead of ${COVERAGE_HEADERS.length}: ${line.slice(0, 160)}`);
+            continue;
+        }
+        rows.push(Object.fromEntries(COVERAGE_HEADERS.map((header, index) => [header, cells[index] ?? ""])));
+    }
+    if (rows.length === 0)
+        findings.push("Coverage Matrix contains no rule rows");
+    return { rows, findings };
+}
+async function fileHash(filePath) {
+    return createHash("sha256").update(await readFile(filePath)).digest("hex");
+}
+async function inputFileFacts(workspaceRoot, files) {
+    const result = [];
+    for (const file of orderedUnique(files).sort()) {
+        result.push({ path: path.relative(workspaceRoot, file).replaceAll(path.sep, "/"), sha256: await fileHash(file) });
+    }
+    return result;
+}
+function dimensionCounts(rules, matcher) {
+    const selected = rules.filter((rule) => matcher.test(rule.dimension));
+    return [
+        selected.reduce((sum, rule) => sum + rule.requiredTestPoints.length, 0),
+        selected.reduce((sum, rule) => sum + rule.coveredTestPoints.length, 0),
+    ];
+}
+function renderCoverageTable(rules) {
+    return [
+        "| Rule Key | Priority | Dimension | Required | Covered | Missing | Status | Case IDs |",
+        "|---|---|---|---:|---:|---|---|---|",
+        ...rules.map((rule) => `| ${rule.ruleKey} | ${rule.priority} | ${rule.dimension} | ${rule.requiredTestPoints.length} | ${rule.coveredTestPoints.length} | ${rule.missingTestPoints.join(", ") || "—"} | ${rule.status} | ${rule.caseIds.join(", ") || "—"} |`),
+    ];
+}
+export async function analyzeBackendTestCaseCoverage(input) {
+    const layout = input.layout ?? resolveBackendTestLayout(undefined);
+    const findings = [];
+    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, 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]}`);
+        }
+    }
+    const caseById = new Map(cases.map((item) => [item.caseId, item]));
+    const rules = [];
+    const evidenceGaps = [];
+    const conflicts = [];
+    const seenRules = new Set();
+    for (const row of matrix.rows) {
+        const ruleKey = row["Rule Key"].replaceAll("`", "").trim();
+        const priority = row.Priority.trim().toUpperCase();
+        const declaredStatus = row.Status.trim().toUpperCase();
+        if (!RULE_KEY.test(ruleKey))
+            findings.push(`invalid Rule Key: ${ruleKey || "<empty>"}`);
+        if (seenRules.has(ruleKey))
+            findings.push(`duplicate Coverage Matrix Rule Key: ${ruleKey}`);
+        seenRules.add(ruleKey);
+        if (!/^(?:P0|P1|P2)$/.test(priority))
+            findings.push(`${ruleKey} has invalid priority: ${priority}`);
+        if (!/^(?:COVERED|PARTIAL|GAP|CONFLICT)$/.test(declaredStatus))
+            findings.push(`${ruleKey} has invalid status: ${declaredStatus}`);
+        const requiredTestPoints = splitCellTokens(row["Required Test Points"], TEST_POINT);
+        const rowCaseIds = splitCellTokens(row["Case IDs"]).map(canonicalCaseId);
+        if (requiredTestPoints.length === 0 && declaredStatus === "COVERED")
+            findings.push(`${ruleKey} declares COVERED without Required Test Points`);
+        const declaredPoints = orderedUnique(rowCaseIds.flatMap((id) => caseById.get(id)?.testPoints ?? []));
+        const coveredTestPoints = requiredTestPoints.filter((point) => declaredPoints.includes(point));
+        const missingTestPoints = requiredTestPoints.filter((point) => !declaredPoints.includes(point));
+        for (const id of rowCaseIds) {
+            const testCase = caseById.get(id);
+            if (!testCase)
+                findings.push(`${ruleKey} references missing Markdown Case: ${id}`);
+            else if (!testCase.ruleKeys.includes(ruleKey))
+                findings.push(`${id} does not reference Coverage Matrix rule ${ruleKey}`);
+        }
+        for (const testCase of cases.filter((item) => item.ruleKeys.includes(ruleKey))) {
+            if (!rowCaseIds.includes(testCase.caseId))
+                findings.push(`${testCase.caseId} references ${ruleKey} but is absent from its Coverage Matrix Case IDs`);
+        }
+        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)
+            findings.push(`${ruleKey} is missing required test points: ${missingTestPoints.join(", ")}`);
+        if (status === "GAP")
+            evidenceGaps.push(`${ruleKey}: ${row.Rule}`);
+        if (status === "CONFLICT")
+            conflicts.push(`${ruleKey}: ${row.Rule}`);
+        if (status !== "COVERED")
+            findings.push(`${ruleKey} coverage status is ${status}`);
+        rules.push({
+            ruleKey,
+            priority: /^(?:P0|P1|P2)$/.test(priority) ? priority : "P2",
+            source: row.Source || "unavailable",
+            endpointField: row["Endpoint/Field"] || "unavailable",
+            dimension: row.Dimension.trim().toLowerCase() || "other",
+            rule: row.Rule || "unavailable",
+            requiredTestPoints,
+            caseIds: rowCaseIds,
+            declaredStatus: normalizedDeclaredStatus,
+            coveredTestPoints,
+            missingTestPoints,
+            status,
+        });
+    }
+    const extractedOpenApiRules = await extractBackendTestOpenApiRules(input);
+    const knownOperations = orderedUnique(extractedOpenApiRules.map((rule) => operationFromEndpointField(rule.endpointField)).filter((value) => Boolean(value)));
+    for (const affectedOperation of coverageScope.scope.affectedOperations) {
+        if (knownOperations.length > 0 && !knownOperations.includes(affectedOperation))
+            findings.push(`Coverage Scope Affected Operation is absent from bound OpenAPI evidence: ${affectedOperation}`);
+    }
+    const requiredOpenApiRules = extractedOpenApiRules.filter((rule) => {
+        const operation = operationFromEndpointField(rule.endpointField);
+        return Boolean(operation && coverageScope.scope.affectedOperations.includes(operation));
+    });
+    for (const extracted of requiredOpenApiRules) {
+        if (seenRules.has(extracted.ruleKey))
+            continue;
+        findings.push(`Coverage Matrix is missing documented in-scope OpenAPI rule: ${extracted.ruleKey} (${extracted.source})`);
+        seenRules.add(extracted.ruleKey);
+        rules.push({
+            ...extracted,
+            caseIds: [],
+            declaredStatus: "PARTIAL",
+            coveredTestPoints: [],
+            missingTestPoints: extracted.requiredTestPoints,
+            status: "PARTIAL",
+        });
+    }
+    for (const affectedRuleKey of coverageScope.scope.affectedRuleKeys) {
+        if (!seenRules.has(affectedRuleKey))
+            findings.push(`Coverage Scope Affected Rule Key is absent from Coverage Matrix: ${affectedRuleKey}`);
+    }
+    const nonCrossCuttingOwners = new Map();
+    for (const testCase of cases) {
+        if (testCase.ruleKeys.length === 0)
+            findings.push(`${testCase.caseId} missing section or entries: 覆盖规则`);
+        if (testCase.testPoints.length === 0)
+            findings.push(`${testCase.caseId} missing section or entries: 测试点`);
+        if (testCase.scenarioTypes.length === 0)
+            findings.push(`${testCase.caseId} missing section or entries: 场景类型`);
+        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)
+            findings.push(`${testCase.caseId} has duplicate Test Point bindings: ${testCase.duplicateBindingTestPoints.join(", ")}`);
+        const extraBindings = testCase.testPointBindings.filter((binding) => !testCase.testPoints.includes(binding.testPoint));
+        if (extraBindings.length > 0)
+            findings.push(`${testCase.caseId} binds undeclared Test Points: ${orderedUnique(extraBindings.map((binding) => binding.testPoint)).join(", ")}`);
+        for (const binding of testCase.testPointBindings.filter((item) => item.mode !== "cross-cutting")) {
+            const owners = nonCrossCuttingOwners.get(binding.testPoint) ?? [];
+            owners.push(testCase.caseId);
+            nonCrossCuttingOwners.set(binding.testPoint, owners);
+        }
+        for (const ruleKey of testCase.ruleKeys)
+            if (!seenRules.has(ruleKey))
+                findings.push(`${testCase.caseId} references unknown Rule Key: ${ruleKey}`);
+    }
+    for (const [testPoint, owners] of nonCrossCuttingOwners) {
+        const uniqueOwners = orderedUnique(owners);
+        if (uniqueOwners.length > 1)
+            findings.push(`${testPoint} is bound as a non-cross-cutting Test Point by multiple Cases: ${uniqueOwners.join(", ")}`);
+    }
+    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 declaredPointUniverse = new Set(cases.flatMap((item) => item.testPoints));
+    const partitionAssessment = assessScenarioPartitionCoverage(parsedPartitions.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/);
+    const [businessStateCount, coveredBusinessStateCount] = dimensionCounts(rules, /business-state|state-transition|uniqueness|lifecycle/);
+    const invalidPointPattern = /(?:UNKNOWN|CASE-VARIANT|WHITESPACE|EMPTY|NULL|WRONG-TYPE|MIN-1|MAX-PLUS-1|UPPERCASE|PUNCTUATION|SLASH|EMOJI|CONTROL)$/;
+    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-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 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,
+            ruleCount: rules.length,
+            coveredRuleCount: rules.filter((rule) => rule.status === "COVERED").length,
+            testPointCount: rules.reduce((sum, rule) => sum + rule.requiredTestPoints.length, 0),
+            coveredTestPointCount: rules.reduce((sum, rule) => sum + rule.coveredTestPoints.length, 0),
+            enumValueCount,
+            coveredEnumValueCount,
+            invalidEquivalenceClassCount,
+            coveredInvalidEquivalenceClassCount,
+            boundaryPointCount,
+            coveredBoundaryPointCount,
+            formatClassCount,
+            coveredFormatClassCount,
+            businessStateCount,
+            coveredBusinessStateCount,
+            gapCount: evidenceGaps.length,
+            conflictCount: conflicts.length,
+            variantTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "variant").length, 0),
+            assertionTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "assertion").length, 0),
+            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),
+        },
+        cases: cases.map(({ body: _body, ...item }) => item),
+        rules,
+        scenarioPartitions: partitionAssessment.facts,
+        findings: orderedUnique(findings),
+        evidenceGaps,
+        conflicts,
+    });
+    const summary = facts.summary;
+    const markdown = [
+        "# Backend Test Case Coverage Analysis",
+        "",
+        "## Status",
+        "",
+        facts.status,
+        "",
+        "## Coverage Scope",
+        "",
+        `- Change Classification: ${facts.coverageScope.changeClassification}`,
+        `- Coverage Policy: ${facts.coverageScope.coveragePolicy}`,
+        `- Completeness Claim: ${facts.coverageScope.completenessClaim}`,
+        `- Affected Operations: ${facts.coverageScope.affectedOperations.join(", ") || "Unavailable"}`,
+        `- Affected Rule Keys: ${facts.coverageScope.affectedRuleKeys.join(", ") || "Unavailable"}`,
+        `- Regression Floor: ${facts.coverageScope.regressionFloor.join(", ") || "Unavailable"}`,
+        `- 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 |",
+        "|---|---:|---:|",
+        `| Product AC | ${summary.explicitAcCount} | ${summary.coveredAcCount} |`,
+        `| Rules | ${summary.ruleCount} | ${summary.coveredRuleCount} |`,
+        `| Required Test Points | ${summary.testPointCount} | ${summary.coveredTestPointCount} |`,
+        `| Enum | ${summary.enumValueCount} | ${summary.coveredEnumValueCount} |`,
+        `| Boundary | ${summary.boundaryPointCount} | ${summary.coveredBoundaryPointCount} |`,
+        `| Format | ${summary.formatClassCount} | ${summary.coveredFormatClassCount} |`,
+        `| Business State | ${summary.businessStateCount} | ${summary.coveredBusinessStateCount} |`,
+        `| Variant bindings | ${summary.variantTestPointCount} | ${summary.variantTestPointCount} |`,
+        `| Assertion bindings | ${summary.assertionTestPointCount} | ${summary.assertionTestPointCount} |`,
+        `| Cross-cutting bindings | ${summary.crossCuttingTestPointCount} | ${summary.crossCuttingTestPointCount} |`,
+        `| Unclassified bindings | ${summary.unclassifiedTestPointCount} | 0 |`,
+        `| Duplicate bindings | ${summary.duplicateBindingTestPointCount} | 0 |`,
+        "",
+        "## Product Requirement Coverage",
+        "",
+        ...renderCoverageTable(rules.filter((rule) => rule.priority === "P0" || rule.ruleKey.startsWith("AC-"))),
+        "",
+        "## API Operation and Field Rule Coverage",
+        "",
+        ...renderCoverageTable(rules.filter((rule) => rule.priority !== "P0")),
+        "",
+        "## Business State Coverage",
+        "",
+        ...renderCoverageTable(rules.filter((rule) => /business-state|state-transition|uniqueness|lifecycle/.test(rule.dimension))),
+        "",
+        "## Enum Coverage",
+        "",
+        ...renderCoverageTable(rules.filter((rule) => /enum/.test(rule.dimension))),
+        "",
+        "## Boundary and Format Coverage",
+        "",
+        ...renderCoverageTable(rules.filter((rule) => /boundary|length|numeric|format|pattern|charset/.test(rule.dimension))),
+        "",
+        "## Uncovered/Partial Rules",
+        "",
+        ...(rules.filter((rule) => rule.status !== "COVERED").map((rule) => `- ${rule.ruleKey}: ${rule.status}; missing=${rule.missingTestPoints.join(", ") || "none"}`)),
+        ...(rules.every((rule) => rule.status === "COVERED") ? ["- None"] : []),
+        "",
+        "## Conflicts and Evidence Gaps",
+        "",
+        ...([...evidenceGaps, ...conflicts].length ? [...evidenceGaps, ...conflicts].map((item) => `- ${item}`) : ["- None"]),
+        "",
+        "## Matrix/Case Consistency Findings",
+        "",
+        ...(facts.findings.length ? facts.findings.map((item) => `- ${item}`) : ["- None"]),
+        "",
+    ].join("\n");
+    return { facts, markdown };
+}
+function normalizeModuleStem(markdownPath) {
+    return path.posix.basename(markdownPath).replace(/\.md$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+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);
+    return orderedUnique(match?.[1]?.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
+}
+function pytestFunctionRegionStart(source, functionIndex) {
+    let regionStart = source.lastIndexOf("\n", functionIndex - 1) + 1;
+    let cursor = regionStart;
+    while (cursor > 0) {
+        const previousEnd = cursor - 1;
+        const previousStart = source.lastIndexOf("\n", previousEnd - 1) + 1;
+        const previous = source.slice(previousStart, previousEnd).replace(/\r$/, "");
+        if (!previous.trim())
+            break;
+        regionStart = previousStart;
+        cursor = previousStart;
+    }
+    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*\[(?![^\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;
+}
+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 = 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 = 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([
+            ...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],
+            caseIds: orderedUnique(ids),
+            testPoints: orderedUnique([...parameterIds, ...assertionTestPoints, ...crossCuttingTestPoints]),
+            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 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, layout)]));
+    const allSymbols = [];
+    const scriptFiles = [];
+    for (const script of scripts) {
+        const absolute = path.resolve(input.workspaceRoot, script);
+        if (!(await exists(absolute)))
+            continue;
+        scriptFiles.push(absolute);
+        allSymbols.push(...pytestSymbols(script, await readFile(absolute, "utf8")));
+    }
+    const findings = [];
+    const entries = [];
+    for (const testCase of cases) {
+        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));
+        const symbols = orderedUnique(refs.map((item) => item.symbol));
+        const parameterIds = orderedUnique(refs.flatMap((item) => item.parameterIds));
+        const assertionBindings = orderedUnique(refs.flatMap((item) => item.assertionTestPoints));
+        const crossCuttingBindings = orderedUnique(refs.flatMap((item) => item.crossCuttingTestPoints));
+        const variantTestPoints = testCase.testPointBindings.filter((item) => item.mode === "variant").map((item) => item.testPoint);
+        const assertionTestPoints = testCase.testPointBindings.filter((item) => item.mode === "assertion").map((item) => item.testPoint);
+        const crossCuttingTestPoints = testCase.testPointBindings.filter((item) => item.mode === "cross-cutting").map((item) => item.testPoint);
+        const mappedTestPoints = orderedUnique([
+            ...variantTestPoints.filter((point) => parameterIds.includes(point)),
+            ...assertionTestPoints.filter((point) => assertionBindings.includes(point)),
+            ...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 = evidenceOnly && refs.length === 0
+            ? "EXACT_1_TO_1"
+            : refs.length === 0
+                ? "MISSING_PYTEST"
+                : refs.length > 1
+                    ? "MULTIPLE_PYTEST"
+                    : "EXACT_1_TO_1";
+        const entryFindings = [];
+        const payloadAssessment = assessPayloadContract(testCase, refs);
+        const signature = executionSignature(testCase);
+        if (evidenceOnly) {
+            if (refs.length > 0) {
+                status = "SCRIPT_MISMATCH";
+                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 = 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")
+                status = "TEST_POINT_BINDING_DUPLICATE";
+            entryFindings.push(`${testCase.caseId} invalid Markdown Test Point bindings: unclassified=${testCase.unclassifiedTestPoints.join(", ") || "none"}; duplicate=${testCase.duplicateBindingTestPoints.join(", ") || "none"}`);
+        }
+        if (missingVariant.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "VARIANT_PARAMETER_MISSING";
+            entryFindings.push(`${testCase.caseId} missing variant pytest parameter IDs: ${missingVariant.join(", ")}`);
+        }
+        if (missingAssertion.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "ASSERTION_BINDING_MISSING";
+            entryFindings.push(`${testCase.caseId} missing assertion docstring bindings: ${missingAssertion.join(", ")}`);
+        }
+        if (missingCrossCutting.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "CROSS_CUTTING_EVIDENCE_MISSING";
+            entryFindings.push(`${testCase.caseId} missing cross-cutting evidence bindings: ${missingCrossCutting.join(", ")}`);
+        }
+        if (extraPoints.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                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,
+            caseId: testCase.caseId,
+            testPoints: testCase.testPoints,
+            variantTestPoints,
+            assertionTestPoints,
+            crossCuttingTestPoints,
+            mappedTestPoints,
+            ...(declared ? { declaredScript: declared } : {}),
+            ...(declaredPrimarySymbol ? { declaredPrimarySymbol } : {}),
+            expectedScript: expected,
+            actualScripts,
+            pytestSymbols: symbols,
+            parameterIds,
+            cardinality,
+            status,
+            payloadAssessment,
+            executionSignature: signature,
+            findings: entryFindings,
+        });
+    }
+    for (const symbol of allSymbols) {
+        const boundKnown = symbol.caseIds.some((id) => cases.some((testCase) => testCase.caseId === id));
+        if (boundKnown)
+            continue;
+        const unknownId = symbol.caseIds[0];
+        const message = unknownId
+            ? `${symbol.script}#${symbol.symbol} references unknown Markdown Case ${unknownId}`
+            : `${symbol.script}#${symbol.symbol} has no Markdown Case ID`;
+        findings.push(message);
+        entries.push({
+            markdownModule: "—",
+            ...(unknownId ? { caseId: unknownId } : {}),
+            testPoints: symbol.testPoints,
+            variantTestPoints: [],
+            assertionTestPoints: [],
+            crossCuttingTestPoints: [],
+            mappedTestPoints: [],
+            expectedScript: symbol.script,
+            actualScripts: [symbol.script],
+            pytestSymbols: [symbol.symbol],
+            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, 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-v3",
+        schemaVersion: 3,
+        taskId: input.taskId,
+        status: findings.length === 0 ? "PASS" : "FAIL",
+        inputFiles: await inputFileFacts(input.workspaceRoot, [
+            path.join(input.workspaceRoot, ...layout.readmePath.split("/")),
+            ...(await markdownModuleFiles(input.workspaceRoot)),
+            ...scriptFiles,
+        ].filter((file) => file && path.isAbsolute(file))),
+        summary: {
+            markdownModuleCount: modulePaths.length,
+            exactModuleCount,
+            markdownCaseCount: cases.length,
+            exactCorrespondenceCount: caseEntries.filter((entry) => entry.status === "EXACT_1_TO_1").length,
+            primarySymbolCount: orderedUnique(caseEntries.flatMap((entry) => entry.pytestSymbols)).length,
+            missingPytestCount: caseEntries.filter((entry) => entry.status === "MISSING_PYTEST").length,
+            multiplePytestCount: caseEntries.filter((entry) => entry.status === "MULTIPLE_PYTEST").length,
+            extraPytestCount: entries.filter((entry) => entry.cardinality === "0:1").length,
+            scriptMismatchCount: caseEntries.filter((entry) => entry.status === "SCRIPT_MISMATCH").length,
+            testPointCount: cases.reduce((sum, item) => sum + item.testPoints.length, 0),
+            mappedTestPointCount: caseEntries.reduce((sum, entry) => sum + entry.mappedTestPoints.length, 0),
+            variantTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "variant").length, 0),
+            assertionTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "assertion").length, 0),
+            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),
+    });
+    const markdown = [
+        "# Backend Test Markdown → pytest Correspondence",
+        "",
+        "## Status",
+        "",
+        facts.status,
+        "",
+        "## Summary",
+        "",
+        `- Markdown modules: ${facts.summary.markdownModuleCount}`,
+        `- Exact module mappings: ${facts.summary.exactModuleCount}`,
+        `- Markdown Cases: ${facts.summary.markdownCaseCount}`,
+        `- Exact 1:1: ${facts.summary.exactCorrespondenceCount}`,
+        `- Primary pytest symbols: ${facts.summary.primarySymbolCount}`,
+        `- Missing pytest: ${facts.summary.missingPytestCount}`,
+        `- Multiple pytest: ${facts.summary.multiplePytestCount}`,
+        `- Extra pytest: ${facts.summary.extraPytestCount}`,
+        `- Test Points: ${facts.summary.mappedTestPointCount}/${facts.summary.testPointCount}`,
+        `- Variant Test Points: ${facts.summary.variantTestPointCount}`,
+        `- Assertion Test Points: ${facts.summary.assertionTestPointCount}`,
+        `- 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 | 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",
+        "",
+        ...(facts.findings.length ? facts.findings.map((item) => `- ${item}`) : ["- None"]),
+        "",
+    ].join("\n");
+    return { facts, markdown };
+}
+async function readFacts(filePath, schema) {
+    try {
+        const parsed = schema.safeParse(JSON.parse(await readFile(filePath, "utf8")));
+        if (!parsed.success)
+            return { issue: `${path.basename(filePath)} schema invalid: ${parsed.error.issues[0]?.message ?? "unknown"}` };
+        return { value: parsed.data };
+    }
+    catch (error) {
+        return { issue: `${path.basename(filePath)} unavailable: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+async function freshnessIssues(workspaceRoot, inputFiles) {
+    if (!workspaceRoot)
+        return [];
+    const issues = [];
+    for (const item of inputFiles) {
+        const absolute = path.resolve(workspaceRoot, item.path);
+        if (!(await exists(absolute)))
+            issues.push(`input file missing since facts generation: ${item.path}`);
+        else if ((await fileHash(absolute)) !== item.sha256)
+            issues.push(`input file hash changed since facts generation: ${item.path}`);
+    }
+    return issues;
+}
+export async function materializeBackendTestCaseManifestFromFacts(input) {
+    const contractsDir = path.join(input.runDir, "contracts");
+    await mkdir(contractsDir, { recursive: true });
+    const coveragePath = path.join(contractsDir, "backend-test-case-coverage-facts.json");
+    const correspondencePath = path.join(contractsDir, "backend-test-markdown-pytest-correspondence-facts.json");
+    const coverageResult = await readFacts(coveragePath, backendTestCaseCoverageFactsSchema);
+    const correspondenceResult = await readFacts(correspondencePath, backendTestMarkdownPytestCorrespondenceFactsSchema);
+    const coverageCases = new Map((coverageResult.value?.cases ?? []).map((item) => [item.caseId, item]));
+    const correspondenceCases = new Map((correspondenceResult.value?.entries ?? []).filter((item) => item.caseId && item.cardinality !== "0:1").map((item) => [item.caseId, item]));
+    const keyIssues = coverageResult.value && correspondenceResult.value ? [
+        ...[...coverageCases.keys()].filter((caseId) => !correspondenceCases.has(caseId)).map((caseId) => `coverage Case missing from correspondence facts: ${caseId}`),
+        ...[...correspondenceCases.keys()].filter((caseId) => !coverageCases.has(caseId)).map((caseId) => `correspondence Case missing from coverage facts: ${caseId}`),
+        ...[...coverageCases.entries()].flatMap(([caseId, testCase]) => {
+            const mapping = correspondenceCases.get(caseId);
+            return mapping && JSON.stringify([...testCase.testPoints].sort()) !== JSON.stringify([...mapping.testPoints].sort())
+                ? [`Case Test Point keys disagree between facts: ${caseId}`]
+                : [];
+        }),
+    ] : [];
+    const sourceFactsIssues = orderedUnique([
+        ...(coverageResult.issue ? [coverageResult.issue] : []),
+        ...(correspondenceResult.issue ? [correspondenceResult.issue] : []),
+        ...(coverageResult.value?.taskId !== undefined && coverageResult.value.taskId !== input.sourceBinding.taskId ? ["coverage facts taskId does not match source binding"] : []),
+        ...(coverageResult.value && JSON.stringify(coverageResult.value.sourceBinding) !== JSON.stringify(input.sourceBinding) ? ["coverage facts source binding does not match manifest source binding"] : []),
+        ...(correspondenceResult.value?.taskId !== undefined && correspondenceResult.value.taskId !== input.sourceBinding.taskId ? ["correspondence facts taskId does not match source binding"] : []),
+        ...keyIssues,
+        ...(coverageResult.value ? await freshnessIssues(input.workspaceRoot, coverageResult.value.inputFiles) : []),
+        ...(correspondenceResult.value ? await freshnessIssues(input.workspaceRoot, correspondenceResult.value.inputFiles) : []),
+    ]);
+    const materializationStatus = !coverageResult.value && !correspondenceResult.value
+        ? "unavailable"
+        : sourceFactsIssues.length > 0 || !coverageResult.value || !correspondenceResult.value
+            ? "partial"
+            : "available";
+    const correspondenceByCase = new Map((correspondenceResult.value?.entries ?? [])
+        .filter((entry) => entry.caseId && entry.cardinality !== "0:1")
+        .map((entry) => [entry.caseId, entry]));
+    const manifestCases = (coverageResult.value?.cases ?? []).map((testCase) => {
+        const mapping = correspondenceByCase.get(testCase.caseId);
+        const generated = Boolean(mapping && mapping.pytestSymbols.length > 0 && mapping.actualScripts.length > 0);
+        return {
+            caseId: testCase.caseId,
+            acIds: testCase.acIds,
+            title: testCase.title,
+            category: inferCategory(testCase.scenarioTypes),
+            automationStatus: generated ? "generated" : "planned",
+            ruleRefs: testCase.ruleKeys,
+            ...(generated ? { file: mapping.actualScripts[0], symbol: mapping.pytestSymbols[0] } : { gapReason: "pytest correspondence is missing or unavailable" }),
+        };
+    });
+    const base = {
+        schemaVersion: 1,
+        sourceBinding: input.sourceBinding,
+        cases: manifestCases,
+        evidenceGaps: [],
+    };
+    const coverageSummary = materializationStatus === "available" ? computeCaseManifestCoverageSummary(base) : undefined;
+    const manifest = backendTestCaseManifestSchema.parse({
+        ...base,
+        materializationStatus,
+        sourceFactsIssues,
+        coverageScope: coverageResult.value?.coverageScope,
+        ruleCoverageSummary: coverageResult.value?.summary,
+        correspondenceSummary: correspondenceResult.value?.summary,
+        artifactRefs: {
+            caseCoverageFacts: await artifactRef(input.runDir, coveragePath),
+            correspondenceFacts: await artifactRef(input.runDir, correspondencePath),
+        },
+        ...(coverageSummary ? { coverageSummary } : {}),
+    });
+    await writeFile(path.join(contractsDir, "backend-test-case-manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+    return manifest;
+}
+function inferCategory(types) {
+    const text = types.join(" ").toLowerCase();
+    if (/negative|invalid|error/.test(text))
+        return "negative";
+    if (/boundary|format|enum/.test(text))
+        return "boundary";
+    if (/state|business|lifecycle|uniqueness/.test(text))
+        return "state-transition";
+    if (/auth|permission/.test(text))
+        return "auth";
+    if (/timeout/.test(text))
+        return "timeout";
+    if (/concurr/.test(text))
+        return "concurrency";
+    if (/positive|requirement/.test(text))
+        return "positive";
+    return "other";
+}
+async function artifactRef(runDir, absolutePath) {
+    if (!(await exists(absolutePath)))
+        return { path: path.relative(runDir, absolutePath).replaceAll(path.sep, "/") };
+    return { path: path.relative(runDir, absolutePath).replaceAll(path.sep, "/"), sha256: await fileHash(absolutePath) };
+}