@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.1

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

@@ -1,5 +1,4 @@
 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";
@@ -9,15 +8,7 @@ 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 RULE_KEY = /^(?:AC|REQ|BR|API|GET|POST|PUT|PATCH|DELETE)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
 const TEST_POINT = /^TP-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
 const COVERAGE_HEADERS = [
     "Rule Key",
@@ -96,13 +87,6 @@ const coverageCaseSchema = z.object({
     scenarioTypes: z.array(z.string()),
     declaredScripts: z.array(z.string()),
     declaredPrimarySymbols: z.array(z.string()),
-    payloadContract: z.object({
-        declared: z.boolean(),
-        noPayload: z.boolean(),
-        requiredPaths: z.array(z.string()),
-        allowedPaths: z.array(z.string()),
-        enumValues: z.record(z.string(), z.array(z.string())),
-    }).strict(),
 }).strict();
 const coverageRuleSchema = z.object({
     ruleKey: z.string().min(1),
@@ -118,23 +102,6 @@ const coverageRuleSchema = z.object({
     missingTestPoints: z.array(z.string()),
     status: z.enum(["COVERED", "PARTIAL", "GAP", "CONFLICT"]),
 }).strict();
-const sourceCoverageFactSchema = z.object({
-    kind: z.enum(["requirement-id", "error-code", "dto-field", "business-rule"]),
-    key: z.string().min(1),
-    sourcePath: z.string().min(1),
-    sourceSha256: sha256Schema,
-    lineStart: z.number().int().positive(),
-    lineEnd: z.number().int().positive(),
-    quote: z.string().min(1).max(1000),
-    covered: z.boolean(),
-}).strict();
-const sourceCoverageSchema = z.object({
-    sourceFactCount: z.number().int().min(0),
-    coveredSourceFactCount: z.number().int().min(0),
-    residualSourceFactCount: z.number().int().min(0),
-    facts: z.array(sourceCoverageFactSchema),
-    residual: z.array(sourceCoverageFactSchema),
-}).strict();
 const coverageScopeSchema = z.object({
     changeClassification: z.enum(CHANGE_CLASSIFICATIONS),
     coveragePolicy: z.enum(COVERAGE_POLICIES),
@@ -145,14 +112,13 @@ const coverageScopeSchema = z.object({
     completenessClaim: z.enum(["affected-operations-full", "affected-scope"]),
 }).strict();
 export const backendTestCaseCoverageFactsSchema = z.object({
-    schemaId: z.literal("backend-test-case-coverage-facts-v4"),
-    schemaVersion: z.literal(4),
+    schemaId: z.literal("backend-test-case-coverage-facts-v3"),
+    schemaVersion: z.literal(3),
     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),
@@ -211,24 +177,12 @@ const correspondenceEntrySchema = z.object({
         "CROSS_CUTTING_EVIDENCE_MISSING",
         "TEST_POINT_BINDING_DUPLICATE",
         "TEST_POINT_BINDING_EXTRA",
-        "PAYLOAD_CONTRACT_UNAVAILABLE",
-        "PAYLOAD_SHAPE_MISMATCH",
     ]),
-    payloadAssessment: z.object({
-        status: z.enum(["SAFE", "UNSAFE", "UNAVAILABLE"]),
-        requiredPaths: z.array(z.string()),
-        allowedPaths: z.array(z.string()),
-        observedPaths: z.array(z.string()),
-        missingPaths: z.array(z.string()),
-        unexpectedPaths: z.array(z.string()),
-        enumMismatches: z.array(z.string()),
-    }).strict(),
-    executionSignature: z.string().min(1).optional(),
     findings: z.array(z.string()),
 }).strict();
 export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
-    schemaId: z.literal("backend-test-markdown-pytest-correspondence-facts-v3"),
-    schemaVersion: z.literal(3),
+    schemaId: z.literal("backend-test-markdown-pytest-correspondence-facts-v2"),
+    schemaVersion: z.literal(2),
     taskId: z.string().min(1),
     status: z.enum(["PASS", "FAIL", "UNAVAILABLE"]),
     inputFiles: z.array(inputFileSchema),
@@ -249,10 +203,6 @@ export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
         crossCuttingTestPointCount: z.number().int().min(0),
         unclassifiedTestPointCount: z.number().int().min(0),
         duplicateBindingTestPointCount: z.number().int().min(0),
-        payloadSafeCount: z.number().int().min(0),
-        payloadUnsafeCount: z.number().int().min(0),
-        payloadUnavailableCount: z.number().int().min(0),
-        duplicateExecutionSignatureCount: z.number().int().min(0),
     }).strict(),
     entries: z.array(correspondenceEntrySchema),
     findings: z.array(z.string()),
@@ -286,64 +236,6 @@ function openApiTestPoints(field, dimension, values = []) {
         return [`${prefix}-VALID-CLASS`, `${prefix}-VALID-MIXED`, `${prefix}-UPPERCASE`, `${prefix}-WHITESPACE`, `${prefix}-PUNCTUATION`, `${prefix}-SLASH`, `${prefix}-EMOJI`, `${prefix}-CONTROL`];
     return [`${prefix}-PRESENT`, `${prefix}-MISSING`, `${prefix}-NULL`, `${prefix}-WRONG-TYPE`];
 }
-async function collectSourceCoverageFacts(input) {
-    const paths = orderedUnique([
-        input.sourceBinding.requirementPath,
-        ...input.sourceBinding.referencePaths,
-    ]);
-    const facts = [];
-    const seen = new Set();
-    for (const sourcePath of paths) {
-        const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, sourcePath);
-        let text;
-        try {
-            text = await readFile(physicalPath, "utf8");
-        }
-        catch {
-            continue;
-        }
-        const sourceSha256 = createHash("sha256").update(await readFile(physicalPath)).digest("hex");
-        const lines = text.split(/\r?\n/);
-        const add = (kind, key, lineIndex, quote) => {
-            const normalizedQuote = quote.trim().slice(0, 1000);
-            if (!normalizedQuote)
-                return;
-            const identity = `${kind}:${key}:${sourcePath}:${lineIndex + 1}`;
-            if (seen.has(identity))
-                return;
-            seen.add(identity);
-            const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const covered = kind === "business-rule"
-                ? input.generatedMarkdown.includes(normalizedQuote)
-                : new RegExp(`\\b${escaped}\\b`).test(input.generatedMarkdown);
-            facts.push({
-                kind,
-                key,
-                sourcePath,
-                sourceSha256,
-                lineStart: lineIndex + 1,
-                lineEnd: lineIndex + 1,
-                quote: normalizedQuote,
-                covered,
-            });
-        };
-        lines.forEach((line, lineIndex) => {
-            for (const key of line.match(SOURCE_RULE_ID_IN_TEXT) ?? [])
-                add("requirement-id", key, lineIndex, line);
-            for (const key of line.match(SOURCE_ERROR_CODE_IN_TEXT) ?? [])
-                add("error-code", key, lineIndex, line);
-            for (const match of line.matchAll(JSON_FIELD_IN_TEXT))
-                add("dto-field", match[1], lineIndex, line);
-            for (const match of line.matchAll(DTO_FIELD_IN_TEXT))
-                add("dto-field", match[1], lineIndex, line);
-            const trimmed = line.trim();
-            if (trimmed.length >= 8 && trimmed.length <= 1000 && !/^\s*(?:#|\||[-:]{3,})/.test(trimmed) && NATURAL_BUSINESS_RULE_KEYWORDS.test(trimmed) && NATURAL_BUSINESS_RULE_NORMATIVE.test(trimmed)) {
-                add("business-rule", `BR-SOURCE-${sourceSha256.slice(0, 8).toUpperCase()}-L${lineIndex + 1}`, lineIndex, trimmed);
-            }
-        });
-    }
-    return facts.sort((left, right) => left.kind.localeCompare(right.kind) || left.key.localeCompare(right.key) || left.sourcePath.localeCompare(right.sourcePath) || left.lineStart - right.lineStart);
-}
 function resolveBoundSourcePath(workspaceRoot, taskId, sourcePath) {
     if (path.isAbsolute(sourcePath))
         return sourcePath;
@@ -493,14 +385,8 @@ function sectionBody(body, aliases) {
 }
 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")) ?? []);
+    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)
@@ -537,40 +423,8 @@ function testPointBindingFacts(body, testPoints) {
 }
 function declaredPrimarySymbols(body) {
     const value = automationLabelBody(body, ["primary symbol", "Primary Symbol", "主测试符号"]);
-    if (/^(?:none|无|n\/a|not-applicable)$/i.test(value.trim()))
-        return [];
     return orderedUnique(value.match(/\btest_[A-Za-z0-9_]+\b/g) ?? []);
 }
-function isEvidenceOnlyMarkdownCase(testCase) {
-    const hasVariant = testCase.testPointBindings.some((item) => item.mode === "variant");
-    const hasNonVariant = testCase.testPointBindings.some((item) => item.mode === "assertion" || item.mode === "cross-cutting");
-    return (testCase.declaredScripts.length === 0 &&
-        testCase.declaredPrimarySymbols.length === 0 &&
-        !hasVariant &&
-        hasNonVariant);
-}
-function payloadContract(body) {
-    const contractValue = automationLabelBody(body, ["Payload Contract", "载荷合同"]);
-    const requiredValue = automationLabelBody(body, ["Payload Required Paths", "载荷必需路径"]);
-    const allowedValue = automationLabelBody(body, ["Payload Allowed Paths", "载荷允许路径"]);
-    const enumValue = automationLabelBody(body, ["Payload Enum", "载荷枚举"]);
-    const tokens = (value) => orderedUnique(value.split(/[,;，；]/).map((item) => item.trim()).filter((item) => /^[A-Za-z_][A-Za-z0-9_.]*$/.test(item)));
-    const enumValues = {};
-    for (const assignment of enumValue.split(/[,;，；]/).map((item) => item.trim()).filter(Boolean)) {
-        const match = /^([A-Za-z_][A-Za-z0-9_.]*)\s*=\s*(.+)$/.exec(assignment);
-        if (!match)
-            continue;
-        enumValues[match[1]] = orderedUnique(match[2].split(/\||\//).map((item) => item.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean));
-    }
-    const noPayload = /^(?:none|无|not-applicable|n\/a)$/i.test(contractValue);
-    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;
 }
@@ -612,7 +466,6 @@ async function parseMarkdownCases(workspaceRoot) {
                 scenarioTypes: scenarioTypes(body),
                 declaredScripts: declaredScripts(body),
                 declaredPrimarySymbols: declaredPrimarySymbols(body),
-                payloadContract: payloadContract(body),
                 body,
             });
         }
@@ -630,17 +483,8 @@ function parseTableRow(line) {
             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 = "";
-            }
+            cells.push(current.trim());
+            current = "";
         }
         else {
             current += char;
@@ -843,10 +687,7 @@ export async function analyzeBackendTestCaseCoverage(input) {
             if (!rowCaseIds.includes(testCase.caseId))
                 findings.push(`${testCase.caseId} references ${ruleKey} but is absent from its Coverage Matrix Case IDs`);
         }
-        const normalizedDeclaredStatus = /^(?:COVERED|PARTIAL|GAP|CONFLICT)$/.test(declaredStatus)
-            ? declaredStatus
-            : "PARTIAL";
-        let status = normalizedDeclaredStatus;
+        let status = declaredStatus;
         if (status === "COVERED" && missingTestPoints.length > 0)
             status = "PARTIAL";
         if (missingTestPoints.length > 0)
@@ -866,7 +707,7 @@ export async function analyzeBackendTestCaseCoverage(input) {
             rule: row.Rule || "unavailable",
             requiredTestPoints,
             caseIds: rowCaseIds,
-            declaredStatus: normalizedDeclaredStatus,
+            declaredStatus: /^(?:COVERED|PARTIAL|GAP|CONFLICT)$/.test(declaredStatus) ? declaredStatus : "PARTIAL",
             coveredTestPoints,
             missingTestPoints,
             status,
@@ -908,12 +749,8 @@ export async function analyzeBackendTestCaseCoverage(input) {
             findings.push(`${testCase.caseId} missing section or entries: 测试点`);
         if (testCase.scenarioTypes.length === 0)
             findings.push(`${testCase.caseId} missing section or entries: 场景类型`);
-        if (isEvidenceOnlyMarkdownCase(testCase)) {
-            // Evidence-only meta cases intentionally declare 脚本/primary symbol as 无 and only keep assertion/cross-cutting TPs.
-        }
-        else if (testCase.declaredPrimarySymbols.length !== 1) {
+        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)
@@ -935,28 +772,8 @@ export async function analyzeBackendTestCaseCoverage(input) {
         if (uniqueOwners.length > 1)
             findings.push(`${testPoint} is bound as a non-cross-cutting Test Point by multiple Cases: ${uniqueOwners.join(", ")}`);
     }
-    const 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 explicitAc = input.sourceBinding.requirementIds.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}`);
-    }
     const [enumValueCount, coveredEnumValueCount] = dimensionCounts(rules, /enum/);
     const [boundaryPointCount, coveredBoundaryPointCount] = dimensionCounts(rules, /boundary|length|numeric/);
     const [formatClassCount, coveredFormatClassCount] = dimensionCounts(rules, /format|pattern|charset/);
@@ -965,8 +782,8 @@ export async function analyzeBackendTestCaseCoverage(input) {
     const invalidEquivalenceClassCount = rules.reduce((sum, rule) => sum + rule.requiredTestPoints.filter((point) => invalidPointPattern.test(point)).length, 0);
     const coveredInvalidEquivalenceClassCount = rules.reduce((sum, rule) => sum + rule.coveredTestPoints.filter((point) => invalidPointPattern.test(point)).length, 0);
     const facts = backendTestCaseCoverageFactsSchema.parse({
-        schemaId: "backend-test-case-coverage-facts-v4",
-        schemaVersion: 4,
+        schemaId: "backend-test-case-coverage-facts-v3",
+        schemaVersion: 3,
         taskId: input.sourceBinding.taskId,
         status: findings.length === 0 ? "PASS" : "FAIL",
         sourceBinding: input.sourceBinding,
@@ -979,13 +796,6 @@ export async function analyzeBackendTestCaseCoverage(input) {
             }))).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,
@@ -1036,22 +846,6 @@ export async function analyzeBackendTestCaseCoverage(input) {
         `- Scope Evidence: ${facts.coverageScope.scopeEvidence.join(", ") || "Unavailable"}`,
         ...(facts.coverageScope.completenessClaim === "affected-scope" ? ["- Coverage is scoped to affected operations; it is not whole-API completeness."] : ["- Coverage fully evaluates the declared affected operations; it is not whole-API completeness unless every operation is explicitly listed."]),
         "",
-        "## Source Coverage Inventory",
-        "",
-        `- Source facts: ${facts.sourceCoverage.sourceFactCount}`,
-        `- Covered source facts: ${facts.sourceCoverage.coveredSourceFactCount}`,
-        `- Residual source facts: ${facts.sourceCoverage.residualSourceFactCount}`,
-        "",
-        "| Kind | Key | Source Anchor | Source SHA-256 | Exact Quote | Status |",
-        "|---|---|---|---|---|---|",
-        ...facts.sourceCoverage.facts.map((fact) => `| ${fact.kind} | ${fact.key} | ${fact.sourcePath}:L${fact.lineStart} | ${fact.sourceSha256} | ${fact.quote.replaceAll("|", "\\|")} | ${fact.covered ? "COVERED" : "MISSING_AFTER_SYNC"} |`),
-        "",
-        "## Residual Missing Source Scenarios",
-        "",
-        ...(facts.sourceCoverage.residual.length > 0
-            ? facts.sourceCoverage.residual.map((fact) => `- ${fact.kind} \`${fact.key}\` from \`${fact.sourcePath}:L${fact.lineStart}\` (sha256 \`${fact.sourceSha256}\`), quote: “${fact.quote}”: missing after the bounded Markdown synchronization round; no full-coverage claim is allowed.`)
-            : ["- None"]),
-        "",
         "## Coverage Summary",
         "",
         "| Dimension | Total | Covered |",
@@ -1115,103 +909,6 @@ 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={}
-for top in tree.body:
-    if isinstance(top,ast.Assign):
-        names=[target.id for target in top.targets if isinstance(target,ast.Name)]
-        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
-FUNCTION_PAYLOADS={}
-for top in tree.body:
-    if isinstance(top,(ast.FunctionDef,ast.AsyncFunctionDef)) and not top.name.startswith('test_'):
-        candidates=[]
-        assigned={}
-        for node in ast.walk(top):
-            if isinstance(node,ast.Assign) and isinstance(node.value,ast.Dict):
-                for target in node.targets:
-                    if isinstance(target,ast.Name): assigned[target.id]=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: candidates.append(assigned[node.value.id])
-        if candidates: FUNCTION_PAYLOADS[top.name]=candidates
-
-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
-        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)
-
-def payload_nodes(fn):
-    result=[]
-    for dec in fn.decorator_list:
-        for node in ast.walk(dec):
-            if isinstance(node,ast.Call) and isinstance(node.func,ast.Attribute) and node.func.attr == 'param' and node.args:
-                if isinstance(node.args[0],ast.Dict): result.append(node.args[0])
-            elif isinstance(node,ast.Name) and node.id in GLOBAL_PAYLOADS:
-                result.extend(GLOBAL_PAYLOADS[node.id])
-    for node in ast.walk(fn):
-        if isinstance(node,ast.Assign):
-            names=[target.id for target in node.targets if isinstance(target,ast.Name)]
-            if any(name.lower() in {'payload','body','request_body','request_json','dto'} for name in names) and isinstance(node.value,ast.Dict): result.append(node.value)
-        if isinstance(node,ast.Call):
-            if isinstance(node.func,ast.Name) and node.func.id in FUNCTION_PAYLOADS:
-                result.extend(FUNCTION_PAYLOADS[node.func.id])
-                override_keys=[]; override_values=[]
-                for keyword in node.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))
-            for keyword in node.keywords:
-                if keyword.arg in {'json','data','payload','body','request_body'} and isinstance(keyword.value,ast.Dict): result.append(keyword.value)
-    return result
-
-out={}
-for fn in ast.walk(tree):
-    if isinstance(fn,(ast.FunctionDef,ast.AsyncFunctionDef)) and fn.name.startswith('test_'):
-        paths=set(); values={}
-        for node in payload_nodes(fn): collect_dict(node,'',paths,values)
-        out[fn.name]={'paths':sorted(paths),'values':{key:sorted(items) for key,items in sorted(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);
@@ -1231,27 +928,6 @@ function pytestFunctionRegionStart(source, functionIndex) {
     }
     return regionStart;
 }
-function pytestFunctionBodyEnd(source, signatureEnd, functionIndent) {
-    let cursor = source.indexOf("\n", signatureEnd);
-    if (cursor < 0)
-        return source.length;
-    cursor += 1;
-    const baseIndent = functionIndent.replaceAll("\t", "    ").length;
-    while (cursor < source.length) {
-        const nextLine = source.indexOf("\n", cursor);
-        const lineEnd = nextLine < 0 ? source.length : nextLine;
-        const line = source.slice(cursor, lineEnd).replace(/\r$/, "");
-        if (line.trim()) {
-            const indentation = line.match(/^[ \t]*/)?.[0]?.replaceAll("\t", "    ").length ?? 0;
-            if (indentation <= baseIndent)
-                return cursor;
-        }
-        if (nextLine < 0)
-            return source.length;
-        cursor = nextLine + 1;
-    }
-    return source.length;
-}
 function pytestParameterCollections(source) {
     const collections = new Map();
     for (const match of source.matchAll(/^([A-Z][A-Z0-9_]*)\s*=\s*\[([\s\S]*?)^\]/gm)) {
@@ -1263,13 +939,12 @@ 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 regionEnd = regionStarts[index + 1] ?? source.length;
         const region = source.slice(match.index, regionEnd);
         const decorators = source.slice(regionStart, match.index);
-        const ids = metadataCaseIds(region);
+        const ids = caseIds(region);
         const fromSymbol = symbolCaseId(match[2]);
         if (fromSymbol)
             ids.unshift(fromSymbol);
@@ -1279,7 +954,6 @@ function pytestSymbols(script, source) {
         ]);
         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],
@@ -1288,51 +962,9 @@ function pytestSymbols(script, source) {
             parameterIds,
             assertionTestPoints,
             crossCuttingTestPoints,
-            payloadPaths: payloadShape.paths,
-            payloadValues: payloadShape.values,
         };
     });
 }
-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 observedPaths = orderedUnique(refs.flatMap((item) => item.payloadPaths));
-    const requiredPaths = testCase.payloadContract.requiredPaths;
-    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 = [];
-    for (const [field, allowed] of Object.entries(testCase.payloadContract.enumValues)) {
-        const observed = orderedUnique(refs.flatMap((item) => item.payloadValues[field] ?? []).map((value) => value.replace(/^['"]|['"]$/g, "")));
-        for (const value of observed)
-            if (!allowed.includes(value))
-                enumMismatches.push(`${field}=${value}; allowed=${allowed.join("|")}`);
-    }
-    return {
-        status: missingPaths.length > 0 || unexpectedPaths.length > 0 || enumMismatches.length > 0 ? "UNSAFE" : "SAFE",
-        requiredPaths,
-        allowedPaths,
-        observedPaths,
-        missingPaths,
-        unexpectedPaths,
-        enumMismatches,
-    };
-}
 export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const cases = await parseMarkdownCases(input.workspaceRoot);
     const modulePaths = orderedUnique(cases.map((item) => item.markdownPath));
@@ -1366,44 +998,21 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             ...crossCuttingTestPoints.filter((point) => crossCuttingBindings.includes(point)),
         ]);
         const declaredPrimarySymbol = testCase.declaredPrimarySymbols[0];
-        const evidenceOnly = isEvidenceOnlyMarkdownCase(testCase);
         const cardinality = refs.length === 0 ? "1:0" : refs.length === 1 ? "1:1" : "1:N";
-        let status = evidenceOnly && refs.length === 0
-            ? "EXACT_1_TO_1"
-            : refs.length === 0
-                ? "MISSING_PYTEST"
-                : refs.length > 1
-                    ? "MULTIPLE_PYTEST"
-                    : "EXACT_1_TO_1";
+        let status = 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) {
+        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} evidence-only Markdown Case must not materialize a business pytest symbol; actualSymbols=${symbols.join(", ") || "none"}`);
-            }
+            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"}`);
         }
-        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 missingVariant = variantTestPoints.filter((point) => !parameterIds.includes(point));
+        const missingAssertion = assertionTestPoints.filter((point) => !assertionBindings.includes(point));
+        const missingCrossCutting = 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")
@@ -1430,16 +1039,6 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
                 status = "TEST_POINT_BINDING_EXTRA";
             entryFindings.push(`${testCase.caseId} has extra pytest Test Point bindings: ${extraPoints.join(", ")}`);
         }
-        if (payloadAssessment.status === "UNAVAILABLE") {
-            if (refs.length > 0 && status === "EXACT_1_TO_1")
-                status = "PAYLOAD_CONTRACT_UNAVAILABLE";
-            entryFindings.push(`${testCase.caseId} has no deterministic Payload Contract declaration`);
-        }
-        else if (payloadAssessment.status === "UNSAFE") {
-            if (refs.length > 0 && status === "EXACT_1_TO_1")
-                status = "PAYLOAD_SHAPE_MISMATCH";
-            entryFindings.push(`${testCase.caseId} payload contract mismatch: missing=${payloadAssessment.missingPaths.join(", ") || "none"}; unexpected=${payloadAssessment.unexpectedPaths.join(", ") || "none"}; enum=${payloadAssessment.enumMismatches.join(", ") || "none"}`);
-        }
         findings.push(...entryFindings);
         entries.push({
             markdownModule: testCase.markdownPath,
@@ -1457,8 +1056,6 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             parameterIds,
             cardinality,
             status,
-            payloadAssessment,
-            executionSignature: signature,
             findings: entryFindings,
         });
     }
@@ -1485,27 +1082,9 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             parameterIds: symbol.parameterIds,
             cardinality: "0:1",
             status: unknownId ? "EXTRA_PYTEST" : "SYMBOL_MISSING_CASE_ID",
-            payloadAssessment: {
-                status: "UNAVAILABLE",
-                requiredPaths: [],
-                allowedPaths: [],
-                observedPaths: symbol.payloadPaths,
-                missingPaths: [],
-                unexpectedPaths: [],
-                enumMismatches: [],
-            },
             findings: [message],
         });
     }
-    const duplicateSignatures = new Map();
-    for (const entry of entries.filter((item) => item.caseId && item.executionSignature)) {
-        const owners = duplicateSignatures.get(entry.executionSignature) ?? [];
-        owners.push(entry.caseId);
-        duplicateSignatures.set(entry.executionSignature, owners);
-    }
-    const duplicateSignatureGroups = [...duplicateSignatures.entries()].filter(([, owners]) => orderedUnique(owners).length > 1);
-    for (const [signature, owners] of duplicateSignatureGroups)
-        findings.push(`duplicate execution signature ${signature}: ${orderedUnique(owners).join(", ")}`);
     const exactModuleCount = modulePaths.filter((modulePath) => {
         const expected = expectedScript(modulePath);
         const moduleCases = cases.filter((item) => item.markdownPath === modulePath);
@@ -1513,8 +1092,8 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     }).length;
     const caseEntries = entries.filter((entry) => entry.cardinality !== "0:1");
     const facts = backendTestMarkdownPytestCorrespondenceFactsSchema.parse({
-        schemaId: "backend-test-markdown-pytest-correspondence-facts-v3",
-        schemaVersion: 3,
+        schemaId: "backend-test-markdown-pytest-correspondence-facts-v2",
+        schemaVersion: 2,
         taskId: input.taskId,
         status: findings.length === 0 ? "PASS" : "FAIL",
         inputFiles: await inputFileFacts(input.workspaceRoot, [
@@ -1539,10 +1118,6 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             crossCuttingTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "cross-cutting").length, 0),
             unclassifiedTestPointCount: cases.reduce((sum, item) => sum + item.unclassifiedTestPoints.length, 0),
             duplicateBindingTestPointCount: cases.reduce((sum, item) => sum + item.duplicateBindingTestPoints.length, 0),
-            payloadSafeCount: caseEntries.filter((entry) => entry.payloadAssessment.status === "SAFE").length,
-            payloadUnsafeCount: caseEntries.filter((entry) => entry.payloadAssessment.status === "UNSAFE").length,
-            payloadUnavailableCount: caseEntries.filter((entry) => entry.payloadAssessment.status === "UNAVAILABLE").length,
-            duplicateExecutionSignatureCount: duplicateSignatureGroups.length,
         },
         entries,
         findings: orderedUnique(findings),
@@ -1570,16 +1145,12 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
         `- Cross-Cutting Test Points: ${facts.summary.crossCuttingTestPointCount}`,
         `- Unclassified Test Points: ${facts.summary.unclassifiedTestPointCount}`,
         `- Duplicate Test Point Bindings: ${facts.summary.duplicateBindingTestPointCount}`,
-        `- Payload SAFE: ${facts.summary.payloadSafeCount}`,
-        `- Payload UNSAFE: ${facts.summary.payloadUnsafeCount}`,
-        `- Payload UNAVAILABLE: ${facts.summary.payloadUnavailableCount}`,
-        `- Duplicate Execution Signatures: ${facts.summary.duplicateExecutionSignatureCount}`,
         "",
         "## Correspondence Matrix",
         "",
-        "| Markdown Module | Case ID | Variant | Assertion | Cross-Cutting | Mapped | Declared Script | Primary Symbol | Actual Script | Pytest Symbol | Parameter IDs | 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} |`),
+        "| Markdown Module | Case ID | Variant | Assertion | Cross-Cutting | Mapped | Declared Script | Primary Symbol | Actual Script | Pytest Symbol | Parameter IDs | Cardinality | Status |",
+        "|---|---|---|---|---|---|---|---|---|---|---|---|---|",
+        ...facts.entries.map((entry) => `| ${entry.markdownModule} | ${entry.caseId ?? "—"} | ${entry.variantTestPoints.join(", ") || "—"} | ${entry.assertionTestPoints.join(", ") || "—"} | ${entry.crossCuttingTestPoints.join(", ") || "—"} | ${entry.mappedTestPoints.join(", ") || "—"} | ${entry.declaredScript ?? "—"} | ${entry.declaredPrimarySymbol ?? "—"} | ${entry.actualScripts.join(", ") || "—"} | ${entry.pytestSymbols.join(", ") || "—"} | ${entry.parameterIds.join(", ") || "—"} | ${entry.cardinality} | ${entry.status} |`),
         "",
         "## Findings",
         "",