@tea-agent/loop-agent 0.25.4 → 0.25.5

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

@@ -0,0 +1,964 @@
+import { createHash } from "node:crypto";
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import YAML from "yaml";
+import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
+const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{2,3})\b.*$/gm;
+const CASE_ID_IN_TEXT = /\bBE-[A-Z0-9_-]+-\d{2,3}\b/g;
+const AC_ID_IN_TEXT = /\bAC-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
+const RULE_KEY = /^(?:AC|REQ|BR|API)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
+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 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()),
+    scenarioTypes: z.array(z.string()),
+    declaredScripts: z.array(z.string()),
+}).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();
+export const backendTestCaseCoverageFactsSchema = z.object({
+    schemaId: z.literal("backend-test-case-coverage-facts-v1"),
+    schemaVersion: z.literal(1),
+    taskId: z.string().min(1),
+    status: z.enum(["PASS", "FAIL", "UNAVAILABLE"]),
+    sourceBinding: sourceBindingSchema,
+    inputFiles: z.array(inputFileSchema),
+    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),
+    }).strict(),
+    cases: z.array(coverageCaseSchema),
+    rules: z.array(coverageRuleSchema),
+    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()),
+    declaredScript: 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",
+        "PARAMETER_POINT_MISSING",
+        "PARAMETER_POINT_EXTRA",
+    ]),
+    findings: z.array(z.string()),
+}).strict();
+export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
+    schemaId: z.literal("backend-test-markdown-pytest-correspondence-facts-v1"),
+    schemaVersion: z.literal(1),
+    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),
+        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),
+    }).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`];
+}
+export async function extractBackendTestOpenApiRules(input) {
+    const rules = [];
+    for (const referencePath of input.sourceBinding.referencePaths) {
+        const physicalPath = path.join(input.workspaceRoot, ".harness", "tasks", 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();
+    const match = upper.match(/^(BE-[A-Z0-9_-]+)-(\d{2,3})$/);
+    if (!match)
+        return upper;
+    return `${match[1].replaceAll("_", "-").replace(/-+/g, "-")}-${match[2].padStart(3, "0")}`;
+}
+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("`", "");
+    const source = pattern.source.replace(/^\^/, "").replace(/\$$/, "");
+    return orderedUnique(section.match(new RegExp(source, "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 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) {
+    const dir = path.join(workspaceRoot, "testcase", "md");
+    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) {
+    const result = [];
+    for (const file of await markdownModuleFiles(workspaceRoot)) {
+        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);
+            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: listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT),
+                scenarioTypes: scenarioTypes(body),
+                declaredScripts: declaredScripts(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 === "|") {
+            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 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 findings = [];
+    const readmePath = path.join(input.workspaceRoot, "testcase", "md", "README.md");
+    const readme = (await exists(readmePath)) ? await readFile(readmePath, "utf8") : "";
+    const matrix = parseCoverageMatrix(readme);
+    findings.push(...matrix.findings);
+    const cases = await parseMarkdownCases(input.workspaceRoot);
+    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`);
+        }
+        let status = declaredStatus;
+        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: /^(?:COVERED|PARTIAL|GAP|CONFLICT)$/.test(declaredStatus) ? declaredStatus : "PARTIAL",
+            coveredTestPoints,
+            missingTestPoints,
+            status,
+        });
+    }
+    const extractedOpenApiRules = await extractBackendTestOpenApiRules(input);
+    for (const extracted of extractedOpenApiRules) {
+        if (seenRules.has(extracted.ruleKey))
+            continue;
+        findings.push(`Coverage Matrix is missing documented OpenAPI rule: ${extracted.ruleKey} (${extracted.source})`);
+        seenRules.add(extracted.ruleKey);
+        rules.push({
+            ...extracted,
+            caseIds: [],
+            declaredStatus: "PARTIAL",
+            coveredTestPoints: [],
+            missingTestPoints: extracted.requiredTestPoints,
+            status: "PARTIAL",
+        });
+    }
+    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: 场景类型`);
+        for (const ruleKey of testCase.ruleKeys)
+            if (!seenRules.has(ruleKey))
+                findings.push(`${testCase.caseId} references unknown Rule Key: ${ruleKey}`);
+    }
+    const explicitAc = input.sourceBinding.requirementIds.filter((id) => id.startsWith("AC-"));
+    const coveredAc = new Set(cases.flatMap((item) => item.acIds));
+    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-v1",
+        schemaVersion: 1,
+        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 = path.join(input.workspaceRoot, ".harness", "tasks", input.sourceBinding.taskId, referencePath);
+                return (await exists(physicalPath)) ? physicalPath : "";
+            }))).filter(Boolean),
+        ]),
+        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,
+        },
+        cases: cases.map(({ body: _body, ...item }) => item),
+        rules,
+        findings: orderedUnique(findings),
+        evidenceGaps,
+        conflicts,
+    });
+    const summary = facts.summary;
+    const markdown = [
+        "# Backend Test Case Coverage Analysis",
+        "",
+        "## Status",
+        "",
+        facts.status,
+        "",
+        "## 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} |`,
+        "",
+        "## 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) {
+    return `testcase/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 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 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));
+    return matches.map((match, index) => {
+        const regionStart = regionStarts[index];
+        const regionEnd = regionStarts[index + 1] ?? source.length;
+        const region = source.slice(regionStart, regionEnd);
+        const ids = caseIds(region);
+        const fromSymbol = symbolCaseId(match[2]);
+        if (fromSymbol)
+            ids.unshift(fromSymbol);
+        const parameterIds = orderedUnique([...region.matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]));
+        return {
+            script,
+            symbol: match[2],
+            caseIds: orderedUnique(ids),
+            testPoints: orderedUnique(region.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []),
+            parameterIds,
+        };
+    });
+}
+export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
+    const cases = await parseMarkdownCases(input.workspaceRoot);
+    const modulePaths = orderedUnique(cases.map((item) => item.markdownPath));
+    const scripts = orderedUnique(cases.flatMap((item) => [...item.declaredScripts, expectedScript(item.markdownPath)]));
+    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);
+        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 observedPoints = orderedUnique(refs.flatMap((item) => item.testPoints));
+        let cardinality = refs.length === 0 ? "1:0" : refs.length === 1 ? "1:1" : "1:N";
+        let status = refs.length === 0 ? "MISSING_PYTEST" : refs.length > 1 ? "MULTIPLE_PYTEST" : "EXACT_1_TO_1";
+        const entryFindings = [];
+        if (refs.length === 0)
+            entryFindings.push(`${testCase.caseId} has no pytest symbol`);
+        if (refs.length > 1)
+            entryFindings.push(`${testCase.caseId} maps to multiple pytest symbols: ${symbols.join(", ")}`);
+        if (!declared || declared !== expected || actualScripts.some((script) => script !== expected)) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "SCRIPT_MISMATCH";
+            entryFindings.push(`${testCase.caseId} script mapping mismatch: declared=${declared ?? "none"}, expected=${expected}, actual=${actualScripts.join(", ") || "none"}`);
+        }
+        const missingPoints = testCase.testPoints.filter((point) => {
+            if (testCase.testPoints.length > 1)
+                return !parameterIds.includes(point);
+            return !observedPoints.includes(point) && !parameterIds.includes(point);
+        });
+        const extraPoints = parameterIds.filter((point) => !testCase.testPoints.includes(point));
+        if (missingPoints.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "PARAMETER_POINT_MISSING";
+            entryFindings.push(`${testCase.caseId} missing pytest Test Point IDs: ${missingPoints.join(", ")}`);
+        }
+        if (extraPoints.length > 0) {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "PARAMETER_POINT_EXTRA";
+            entryFindings.push(`${testCase.caseId} has extra pytest parameter IDs: ${extraPoints.join(", ")}`);
+        }
+        findings.push(...entryFindings);
+        entries.push({
+            markdownModule: testCase.markdownPath,
+            caseId: testCase.caseId,
+            testPoints: testCase.testPoints,
+            ...(declared ? { declaredScript: declared } : {}),
+            expectedScript: expected,
+            actualScripts,
+            pytestSymbols: symbols,
+            parameterIds,
+            cardinality,
+            status,
+            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,
+            expectedScript: symbol.script,
+            actualScripts: [symbol.script],
+            pytestSymbols: [symbol.symbol],
+            parameterIds: symbol.parameterIds,
+            cardinality: "0:1",
+            status: unknownId ? "EXTRA_PYTEST" : "SYMBOL_MISSING_CASE_ID",
+            findings: [message],
+        });
+    }
+    const exactModuleCount = modulePaths.filter((modulePath) => {
+        const expected = expectedScript(modulePath);
+        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-v1",
+        schemaVersion: 1,
+        taskId: input.taskId,
+        status: findings.length === 0 ? "PASS" : "FAIL",
+        inputFiles: await inputFileFacts(input.workspaceRoot, [
+            path.join(input.workspaceRoot, "testcase", "md", "README.md"),
+            ...(await markdownModuleFiles(input.workspaceRoot)),
+            ...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,
+            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.testPoints.filter((point) => entry.parameterIds.includes(point) || (entry.testPoints.length === 1 && entry.status === "EXACT_1_TO_1")).length, 0),
+        },
+        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}`,
+        `- Missing pytest: ${facts.summary.missingPytestCount}`,
+        `- Multiple pytest: ${facts.summary.multiplePytestCount}`,
+        `- Extra pytest: ${facts.summary.extraPytestCount}`,
+        `- Test Points: ${facts.summary.mappedTestPointCount}/${facts.summary.testPointCount}`,
+        "",
+        "## Correspondence Matrix",
+        "",
+        "| Markdown Module | Case ID | Test Points | Declared Script | Expected Script | Actual Script | Pytest Symbol | Parameter IDs | Cardinality | Status |",
+        "|---|---|---|---|---|---|---|---|---|---|",
+        ...facts.entries.map((entry) => `| ${entry.markdownModule} | ${entry.caseId ?? "—"} | ${entry.testPoints.join(", ") || "—"} | ${entry.declaredScript ?? "—"} | ${entry.expectedScript} | ${entry.actualScripts.join(", ") || "—"} | ${entry.pytestSymbols.join(", ") || "—"} | ${entry.parameterIds.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,
+        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) };
+}