@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.11

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

@@ -307,14 +307,18 @@ export function classifyBackendTestCorrespondenceRepair(facts, layout) {
         const markdownReasons = [];
         const pytestReasons = [];
         const counts = bindingCounts(entry);
-        if (entry.testPoints.some((point) => (counts.get(point) ?? 0) !== 1) ||
-            [...counts.keys()].some((point) => !entry.testPoints.includes(point))) {
+        if (entry.cardinality !== "0:1" &&
+            entry.testPoints.some((point) => (counts.get(point) ?? 0) !== 1)) {
+            // Only ### 测试点 inventory must be bound exactly once. Extra
+            // automation-mapping TPs (typical: 横切 listed only under 跨切证据)
+            // are pytest-owned docstring/repair defects, not Markdown BLOCKED.
             markdownReasons.push("markdown-test-point-binding-invalid");
         }
         if (entry.declaredScript && entry.declaredScript !== entry.expectedScript) {
             markdownReasons.push("markdown-script-declaration-invalid");
         }
-        if (entry.cardinality === "1:0")
+        const evidenceOnly = isEvidenceOnlyCorrespondenceEntry(entry);
+        if (!evidenceOnly && entry.cardinality === "1:0")
             pytestReasons.push("missing-pytest-symbol");
         if (entry.cardinality === "1:N")
             pytestReasons.push("multiple-pytest-symbols");
@@ -325,12 +329,15 @@ export function classifyBackendTestCorrespondenceRepair(facts, layout) {
         if (entry.declaredPrimarySymbol && entry.pytestSymbols.some((symbol) => symbol !== entry.declaredPrimarySymbol)) {
             pytestReasons.push("pytest-primary-symbol-mismatch");
         }
-        if (entry.variantTestPoints.some((point) => !entry.parameterIds.includes(point)))
+        if (!evidenceOnly && entry.variantTestPoints.some((point) => !entry.parameterIds.includes(point))) {
             pytestReasons.push("variant-parameter-missing");
-        if (entry.assertionTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+        }
+        if (!evidenceOnly && entry.assertionTestPoints.some((point) => !entry.mappedTestPoints.includes(point))) {
             pytestReasons.push("assertion-binding-missing");
-        if (entry.crossCuttingTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+        }
+        if (!evidenceOnly && entry.crossCuttingTestPoints.some((point) => !entry.mappedTestPoints.includes(point))) {
             pytestReasons.push("cross-cutting-binding-missing");
+        }
         if (entry.parameterIds.some((point) => !entry.testPoints.includes(point)))
             pytestReasons.push("pytest-test-point-binding-extra");
         if (entry.payloadAssessment.status === "UNSAFE")
@@ -339,7 +346,7 @@ export function classifyBackendTestCorrespondenceRepair(facts, layout) {
             !["TEST_POINT_BINDING_DUPLICATE", "PAYLOAD_CONTRACT_UNAVAILABLE"].includes(entry.status)) {
             pytestReasons.push(`correspondence-${entry.status.toLowerCase().replaceAll("_", "-")}`);
         }
-        if (entry.status === "PAYLOAD_CONTRACT_UNAVAILABLE") {
+        if (entry.status === "PAYLOAD_CONTRACT_UNAVAILABLE" && entry.cardinality !== "0:1") {
             markdownReasons.push("markdown-payload-contract-unavailable");
         }
         const paths = orderedUnique([entry.expectedScript, ...entry.actualScripts].filter(safePytestPath));
@@ -668,6 +675,92 @@ function automationLabelBody(body, labels) {
     const match = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:]\\s*(.*)$`, "mi").exec(automation);
     return match?.[1]?.replaceAll("`", "").trim() ?? "";
 }
+const BINDING_NEGATION_OR_AMBIGUITY = /(?:不是|并非|非变体|非断言|非横切|可能|待定|或者|\b(?:TBD|unknown)\b)/i;
+function explicitBindingModeFromLine(line) {
+    if (BINDING_NEGATION_OR_AMBIGUITY.test(line))
+        return undefined;
+    const modes = TEST_POINT_BINDING_MODES.filter((mode) => AUTOMATION_BINDING_LABELS[mode].some((label) => line.includes(label)));
+    return modes.length === 1 ? modes[0] : undefined;
+}
+/**
+ * Canonicalize only explicit, unambiguous Test Point classification marks.
+ * The model occasionally writes `TP-X（变体测试点）`, `[场景断言测试点] TP-X`
+ * or a pipe-delimited equivalent. Those forms carry deterministic semantics,
+ * but are not the machine contract consumed by automationLabelBody(). Keep the
+ * original prose and materialize the same binding under `### 自动化映射` as the
+ * canonical single-line labels. Never infer a mode from ordinary prose.
+ */
+export function canonicalizeBackendTestMarkdownTestPointBindings(markdown) {
+    const headings = [...markdown.matchAll(CASE_HEADING)];
+    let output = "";
+    let cursor = 0;
+    const unsafeTestPoints = [];
+    const canonicalizedTestPoints = [];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        const start = heading.index;
+        const end = headings[index + 1]?.index ?? markdown.length;
+        const body = markdown.slice(start, end);
+        output += markdown.slice(cursor, start);
+        cursor = end;
+        const declared = listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT);
+        const current = testPointBindingFacts(body, declared);
+        const currentByMode = new Map(TEST_POINT_BINDING_MODES.map((mode) => [
+            mode,
+            current.testPointBindings.filter((item) => item.mode === mode).map((item) => item.testPoint),
+        ]));
+        const unresolved = new Set(current.unclassifiedTestPoints);
+        for (const line of body.split(/\r?\n/)) {
+            const mode = explicitBindingModeFromLine(line);
+            if (!mode)
+                continue;
+            const tokens = orderedUnique(line.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
+            for (const token of tokens) {
+                if (!unresolved.has(token))
+                    continue;
+                const existingModes = TEST_POINT_BINDING_MODES.filter((candidate) => (currentByMode.get(candidate) ?? []).includes(token));
+                if (existingModes.length > 0)
+                    continue;
+                currentByMode.set(mode, orderedUnique([...(currentByMode.get(mode) ?? []), token]));
+                unresolved.delete(token);
+                canonicalizedTestPoints.push(token);
+            }
+        }
+        unsafeTestPoints.push(...unresolved);
+        if (unresolved.size === current.unclassifiedTestPoints.length) {
+            output += body;
+            continue;
+        }
+        const automationMarker = /^###\s+(?:自动化映射|Automation Mapping)\s*$/mi.exec(body);
+        if (!automationMarker) {
+            output += body;
+            continue;
+        }
+        const automationStart = automationMarker.index + automationMarker[0].length;
+        const rest = body.slice(automationStart);
+        const nextSection = /^###\s+/m.exec(rest);
+        const automationEnd = automationStart + (nextSection?.index ?? rest.length);
+        let automation = body.slice(automationStart, automationEnd);
+        for (const mode of TEST_POINT_BINDING_MODES) {
+            const labels = AUTOMATION_BINDING_LABELS[mode];
+            const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+            const canonicalLine = `- ${AUTOMATION_BINDING_LABELS[mode][0]}：${(currentByMode.get(mode) ?? []).join("; ") || "无"}`;
+            const linePattern = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:].*$`, "mi");
+            if (linePattern.test(automation))
+                automation = automation.replace(linePattern, canonicalLine);
+            else
+                automation = `${automation.replace(/\s*$/, "")}\n${canonicalLine}\n`;
+        }
+        output += body.slice(0, automationStart) + automation + body.slice(automationEnd);
+    }
+    output += markdown.slice(cursor);
+    return {
+        markdown: output,
+        changed: output !== markdown,
+        unsafeTestPoints: orderedUnique(unsafeTestPoints),
+        canonicalizedTestPoints: orderedUnique(canonicalizedTestPoints),
+    };
+}
 export function inspectBackendTestMarkdownTestPointBindings(markdown) {
     const headings = [...markdown.matchAll(CASE_HEADING)];
     return headings.map((heading, index) => {
@@ -710,6 +803,16 @@ function isEvidenceOnlyMarkdownCase(testCase) {
         !hasVariant &&
         hasNonVariant);
 }
+function isEvidenceOnlyCorrespondenceEntry(entry) {
+    return (entry.status === "EXACT_1_TO_1" &&
+        entry.cardinality === "1:0" &&
+        !entry.declaredScript &&
+        !entry.declaredPrimarySymbol &&
+        entry.variantTestPoints.length === 0 &&
+        (entry.assertionTestPoints.length > 0 || entry.crossCuttingTestPoints.length > 0) &&
+        entry.pytestSymbols.length === 0 &&
+        entry.actualScripts.length === 0);
+}
 function payloadContract(body) {
     const contractValue = automationLabelBody(body, ["Payload Contract", "载荷合同"]);
     const requiredValue = automationLabelBody(body, ["Payload Required Paths", "载荷必需路径"]);
@@ -718,7 +821,7 @@ function payloadContract(body) {
     const tokens = (value) => orderedUnique(value
         .split(/[,;，；]/)
         .map((item) => item.trim())
-        .filter((item) => !/^(?:none|无|not-applicable|n\/a)$/i.test(item))
+        .filter((item) => !/^(?:none|无|not-applicable|n\/a|true|false)$/i.test(item))
         .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)) {
@@ -1312,8 +1415,16 @@ export async function analyzeBackendTestCaseCoverage(input) {
 function normalizeModuleStem(markdownPath) {
     return path.posix.basename(markdownPath).replace(/\.md$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
-function expectedScript(markdownPath, layout) {
+function expectedScript(markdownPath, layout, declaredScripts = []) {
     const resolved = layout ?? resolveBackendTestLayout(undefined);
+    if (declaredScripts.length === 1) {
+        const candidate = declaredScripts[0].replaceAll("\\", "/").replace(/^\.\//, "");
+        const prefix = resolved.scriptDir === "." ? "" : `${resolved.scriptDir}/`;
+        const relative = prefix && candidate.startsWith(prefix) ? candidate.slice(prefix.length) : candidate;
+        if ((!prefix || candidate.startsWith(prefix)) && !relative.includes("..") && /^test_[A-Za-z0-9_.-]+\.py$/.test(path.posix.basename(candidate))) {
+            return candidate;
+        }
+    }
     return `${resolved.scriptDir}/test_${normalizeModuleStem(markdownPath)}.py`;
 }
 function symbolCaseId(symbol) {
@@ -1369,8 +1480,15 @@ for top in ast.walk(tree):
                     returned_names.add(node.value.id)
             if isinstance(node,ast.Call):
                 for keyword in node.keywords:
-                    if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
+                    if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
                         transport.append((keyword.value.id,positional.index(keyword.value.id)-call_offset))
+                    if keyword.arg is None and isinstance(keyword.value,ast.Name):
+                        alias=keyword.value.id
+                        assigned_value=assigned.get(alias)
+                        if isinstance(assigned_value,ast.Name) and assigned_value.id in positional:
+                            transport.append((assigned_value.id,positional.index(assigned_value.id)-call_offset))
+                        elif isinstance(assigned_value,ast.Call) and isinstance(assigned_value.func,ast.Name) and assigned_value.func.id == 'dict' and assigned_value.args and isinstance(assigned_value.args[0],ast.Name) and assigned_value.args[0].id in positional:
+                            transport.append((assigned_value.args[0].id,positional.index(assigned_value.args[0].id)-call_offset))
                 if isinstance(node.func,ast.Attribute) and node.func.attr.lower() in {'post','put','patch'} and len(node.args) >= 2:
                     candidate=node.args[1]
                     if isinstance(candidate,ast.Name) and candidate.id in positional:
@@ -1382,6 +1500,17 @@ for top in ast.walk(tree):
                     matched=node.args[nested_position] if nested_position >= 0 and nested_position < len(node.args) else None
                     if isinstance(matched,ast.Name) and matched.id in positional:
                         transport.append((matched.id,positional.index(matched.id)-call_offset))
+        # Assignment order in ast.walk is not source order. Re-scan **kwargs
+        # aliases once the complete local assignment table is available.
+        for node in ast.walk(top):
+            if not isinstance(node,ast.Call): continue
+            for keyword in node.keywords:
+                if keyword.arg is not None or not isinstance(keyword.value,ast.Name): continue
+                assigned_value=assigned.get(keyword.value.id)
+                if isinstance(assigned_value,ast.Name) and assigned_value.id in positional:
+                    transport.append((assigned_value.id,positional.index(assigned_value.id)-call_offset))
+                elif isinstance(assigned_value,ast.Call) and isinstance(assigned_value.func,ast.Name) and assigned_value.func.id == 'dict' and assigned_value.args and isinstance(assigned_value.args[0],ast.Name) and assigned_value.args[0].id in positional:
+                    transport.append((assigned_value.args[0].id,positional.index(assigned_value.args[0].id)-call_offset))
         for returned_name in returned_names:
             entries=mutated.get(returned_name,[])
             if entries:
@@ -1390,7 +1519,7 @@ for top in ast.walk(tree):
         for node in ast.walk(top):
             if not isinstance(node,ast.Call): continue
             for keyword in node.keywords:
-                if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in assigned:
+                if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in assigned:
                     transport_shapes.append(assigned[keyword.value.id])
         if candidates: FUNCTION_PAYLOADS[top.name]=candidates
         if transport_shapes: FUNCTION_TRANSPORT_SHAPES[top.name]=transport_shapes
@@ -1446,8 +1575,9 @@ def literal(node):
         return repr(node.value)
     return None
 
-def collect_dict(node, prefix, paths, values):
+def collect_dict(node, prefix, paths, values, parameters=None):
     if not isinstance(node, ast.Dict): return
+    parameters = parameters or {}
     for key,value in zip(node.keys,node.values):
         if not isinstance(key, ast.Constant) or not isinstance(key.value,str): continue
         # Ignore writer helper/meta keys that are not DTO request fields.
@@ -1457,12 +1587,16 @@ def collect_dict(node, prefix, paths, values):
         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.Name) and value.id in parameters:
+            for bound in parameters[value.id]:
+                bound_lv=literal(bound)
+                if bound_lv is not None: values.setdefault(current,set()).add(bound_lv)
+        if isinstance(value, ast.Dict): collect_dict(value,current,paths,values,parameters)
         elif isinstance(value,(ast.List,ast.Tuple)):
             for item in value.elts:
-                if isinstance(item,ast.Dict): collect_dict(item,current,paths,values)
+                if isinstance(item,ast.Dict): collect_dict(item,current,paths,values,parameters)
 
-PAYLOAD_NAMES={'payload','body','request_body','request_json','dto','json','data','json_body'}
+PAYLOAD_NAMES={'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'}
 
 def shape_only(node):
     if isinstance(node,ast.Dict):
@@ -1543,6 +1677,7 @@ def decorator_payload_nodes(parameters,assigned):
 
 def decorator_payload_nodes_by_tp(fn,assigned):
     result={}
+    function_payload_nodes=payload_nodes(fn)
     for dec in fn.decorator_list:
         if not isinstance(dec,ast.Call) or not isinstance(dec.func,ast.Attribute) or dec.func.attr != 'parametrize' or len(dec.args) < 2: continue
         if not isinstance(dec.args[0],ast.Constant) or not isinstance(dec.args[0].value,str): continue
@@ -1559,9 +1694,11 @@ def decorator_payload_nodes_by_tp(fn,assigned):
             parameters={}
             for index,name in enumerate(names):
                 if index < len(node.args): parameters.setdefault(name,[]).append(node.args[index])
-            payload_nodes=decorator_payload_nodes(parameters,assigned)
+            payload_nodes_for_tp=decorator_payload_nodes(parameters,assigned)
+            if not payload_nodes_for_tp:
+                payload_nodes_for_tp=function_payload_nodes
             paths=set(); values={}
-            for payload_node in payload_nodes: collect_dict(payload_node,'',paths,values)
+            for payload_node in payload_nodes_for_tp: collect_dict(payload_node,'',paths,values,parameters)
             result[tp]={key:sorted(items) for key,items in sorted(values.items())}
     return result
 
@@ -1603,6 +1740,20 @@ def is_direct_transport_call(node):
     if isinstance(current,ast.Name): receiver_tokens.append(current.id.lower())
     return any(token in {'requests','httpx','client','session','api_client','http_client'} or token.endswith('_client') for token in receiver_tokens)
 
+HTTP_METHODS={'GET','POST','PUT','PATCH','DELETE','HEAD','OPTIONS'}
+HTTP_FIXTURE_NAMES={'http','http_client','client','api_client','session'}
+
+def is_fixture_http_call(node):
+    # R12: http("POST", path, json_body={"title": title}) is a Name-call fixture, not client.post.
+    # R15: http_client(operation, path, json_body={...}) still transports when operation is a parametrized method.
+    if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Name) or not node.args: return False
+    first=node.args[0]
+    if isinstance(first,ast.Constant) and isinstance(first.value,str) and first.value.upper() in HTTP_METHODS:
+        return True
+    func=node.func.id.lower()
+    httpish=func in HTTP_FIXTURE_NAMES or func.endswith('_client')
+    return httpish and isinstance(first,ast.Name)
+
 def payload_nodes(fn):
     result=[]
     assigned={}
@@ -1625,7 +1776,7 @@ def payload_nodes(fn):
     # Observe local payload/body variables only when they flow into a direct
     # HTTP transport call. Arbitrary setup variables are not target requests.
     for node in ast.walk(fn):
-        if not is_direct_transport_call(node): continue
+        if not (is_direct_transport_call(node) or is_fixture_http_call(node)): continue
         for keyword in node.keywords:
             if keyword.arg in PAYLOAD_NAMES: result.extend(payload_expr_nodes(keyword.value,assigned,parameters))
     return result
@@ -1635,8 +1786,8 @@ for fn in ast.walk(tree):
     if isinstance(fn,(ast.FunctionDef,ast.AsyncFunctionDef)) and fn.name.startswith('test_'):
         paths=set(); values={}
         fallback_paths=set(); fallback_values={}
-        for node in payload_nodes(fn): collect_dict(node,'',paths,values)
-        for node in fallback_payload_nodes(fn): collect_dict(node,'',fallback_paths,fallback_values)
+        for node in payload_nodes(fn): collect_dict(node,'',paths,values,{})
+        for node in fallback_payload_nodes(fn): collect_dict(node,'',fallback_paths,fallback_values,{})
         out[fn.name]={
             'paths':sorted(paths),
             'values':{key:sorted(items) for key,items in sorted(values.items())},
@@ -1688,14 +1839,39 @@ function metadataTestPoints(region, label) {
     const match = new RegExp(`^\\s*${escaped}\\s*:\\s*(.*)$`, "mi").exec(region);
     return orderedUnique(match?.[1]?.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
 }
+function isPytestDecoratorOrContinuationLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.startsWith("#"))
+        return true;
+    if (trimmed.startsWith("@"))
+        return true;
+    // Multi-line decorator argument lists: @pytest.mark.parametrize(\n    "x", [\n      pytest.param(..., id="TP-...")\n    ]\n)
+    return /^[\]\),]/.test(trimmed) || /[\(\[{,]$/.test(trimmed) || /\bpytest\.param\s*\(/.test(trimmed);
+}
 function pytestFunctionRegionStart(source, functionIndex) {
     let regionStart = source.lastIndexOf("\n", functionIndex - 1) + 1;
     let cursor = regionStart;
+    let blankRun = 0;
     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())
+        const trimmed = previous.trim();
+        if (!trimmed) {
+            blankRun += 1;
+            // Keep walking across a small blank gap so a decorator is still bound to
+            // the following test when writers insert one empty line before `def`.
+            if (blankRun > 2)
+                break;
+            cursor = previousStart;
+            continue;
+        }
+        blankRun = 0;
+        if (/^(?:async\s+)?def\s+/.test(trimmed) || /^(?:async\s+)?class\s+/.test(trimmed))
+            break;
+        if (!isPytestDecoratorOrContinuationLine(previous))
             break;
         regionStart = previousStart;
         cursor = previousStart;
@@ -1725,12 +1901,14 @@ function pytestFunctionBodyEnd(source, signatureEnd, functionIndent) {
 }
 function pytestParameterCollections(source) {
     const collections = new Map();
-    for (const match of source.matchAll(/^(_?[A-Z][A-Z0-9_]*)\s*=\s*\[(?![^\r\n]*\])([\s\S]*?)^\]/gm)) {
+    for (const match of source.matchAll(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\[(?![^\r\n]*\])([\s\S]*?)^\]/gm)) {
         const explicitIds = [...match[2].matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]);
         const factoryIds = explicitIds.length === 0
             ? [...match[2].matchAll(/["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1])
             : [];
-        collections.set(match[1], orderedUnique([...explicitIds, ...factoryIds]));
+        const ids = orderedUnique([...explicitIds, ...factoryIds]);
+        if (ids.length > 0)
+            collections.set(match[1], ids);
     }
     return collections;
 }
@@ -1792,6 +1970,12 @@ function normalizePythonLiteralValue(value) {
     if ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
         return trimmed.slice(1, -1);
     }
+    if (trimmed === "True")
+        return "true";
+    if (trimmed === "False")
+        return "false";
+    if (trimmed === "None")
+        return "null";
     return trimmed;
 }
 function intentionalInvalidEnumVariant(input) {
@@ -1836,13 +2020,15 @@ function assessPayloadContract(testCase, refs) {
             : [];
     const enumMismatches = [];
     for (const [field, allowed] of Object.entries(testCase.payloadContract.enumValues)) {
-        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        const aggregated = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        const byTestPoint = orderedUnique(refs.flatMap((item) => Object.values(item.payloadValuesByTestPoint).flatMap((values) => values[field] ?? [])));
+        const observed = orderedUnique([...aggregated, ...byTestPoint]);
         for (const rawValue of observed) {
             const value = normalizePythonLiteralValue(rawValue);
             if (allowed.includes(value))
                 continue;
             const associatedTestPoints = orderedUnique(refs.flatMap((item) => Object.entries(item.payloadValuesByTestPoint)
-                .filter(([, values]) => (values[field] ?? []).includes(rawValue))
+                .filter(([, values]) => (values[field] ?? []).some((itemValue) => itemValue === rawValue || normalizePythonLiteralValue(itemValue) === value))
                 .map(([testPoint]) => testPoint)));
             const intentionallyInvalid = associatedTestPoints.length > 0 && associatedTestPoints.every((testPoint) => intentionalInvalidEnumVariant({ testCase, testPoint, field, observedValue: rawValue, allowed }));
             if (!intentionallyInvalid)
@@ -1863,7 +2049,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const layout = input.layout ?? resolveBackendTestLayout(undefined);
     const cases = await parseMarkdownCases(input.workspaceRoot, layout);
     const modulePaths = orderedUnique(cases.map((item) => item.markdownPath));
-    const scripts = orderedUnique(cases.flatMap((item) => [...item.declaredScripts, expectedScript(item.markdownPath, layout)]));
+    const scripts = orderedUnique(cases.flatMap((item) => [expectedScript(item.markdownPath, layout, item.declaredScripts)]));
     const allSymbols = [];
     const scriptFiles = [];
     for (const script of scripts) {
@@ -1876,7 +2062,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const findings = [];
     const entries = [];
     for (const testCase of cases) {
-        const expected = expectedScript(testCase.markdownPath, layout);
+        const expected = expectedScript(testCase.markdownPath, layout, testCase.declaredScripts);
         const declared = testCase.declaredScripts[0];
         const refs = allSymbols.filter((item) => item.caseIds.includes(testCase.caseId));
         const actualScripts = orderedUnique(refs.map((item) => item.script));
@@ -2034,8 +2220,9 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     for (const [signature, owners] of duplicateSignatureGroups)
         findings.push(`duplicate execution signature ${signature}: ${orderedUnique(owners).join(", ")}`);
     const exactModuleCount = modulePaths.filter((modulePath) => {
-        const expected = expectedScript(modulePath, layout);
         const moduleCases = cases.filter((item) => item.markdownPath === modulePath);
+        const moduleDeclaredScripts = orderedUnique(moduleCases.flatMap((item) => item.declaredScripts));
+        const expected = expectedScript(modulePath, layout, moduleDeclaredScripts);
         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");

package/dist/workflows/dag/backend-test-markdown-workflow.js

@@ -285,6 +285,7 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         moduleIndexHeadingCount,
         declaredStems: [],
         declaredMdFiles: [],
+        declaredScriptByMarkdown: {},
         declaredMissing: [],
         unmanifested: [],
     });
@@ -306,6 +307,15 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         return invalid("duplicate", moduleIndexHeadingCount);
     }
     const declaredStems = extractDeclaredModuleIndexFilenames(readme);
+    const declaredScriptByMarkdown = {};
+    const mdPrefix = escapeRegExp(`${resolved.markdownDir}/`);
+    const scriptPrefix = escapeRegExp(`${resolved.scriptDir}/`);
+    for (const line of readme.split(/\r?\n/)) {
+        const markdown = new RegExp(`(${mdPrefix}[A-Za-z0-9_.-]+\\.md)`).exec(line)?.[1];
+        const pytest = new RegExp(`(${scriptPrefix}[A-Za-z0-9_./-]+\\.py)`).exec(line)?.[1];
+        if (markdown && pytest)
+            declaredScriptByMarkdown[markdown] = pytest;
+    }
     if (declaredStems.length === 0) {
         return invalid("empty-unparsable", moduleIndexHeadingCount);
     }
@@ -345,6 +355,7 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         moduleIndexHeadingCount,
         declaredStems,
         declaredMdFiles: declaredMdFiles.sort(),
+        declaredScriptByMarkdown,
         declaredMissing: declaredMissing.sort(),
         unmanifested: unmanifested.sort(),
     };
@@ -694,7 +705,8 @@ export async function validateBackendMarkdownCases(input) {
             if (!hasAssertableExpectedResult(expected)) {
                 findings.push(`${testCase.id} has no structured expected result`);
             }
-            const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
+            const expectedScript = manifest.declaredScriptByMarkdown[relativeFile] ??
+                expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
             const mappedScripts = extractMappedPytestScripts(testCase.body);
             if (isEvidenceOnlyMarkdownCaseBody(testCase.body)) {
                 // Evidence-only meta cases intentionally declare 脚本/primary symbol as 无 and keep only assertion/cross-cutting TPs.