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

package/dist/workflows/dag/backend-test-scenario-param.js

@@ -0,0 +1,1670 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { expectedBackendTestPytestScriptForMarkdownModule, } from "./backend-test-markdown-workflow.js";
+import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+export const BACKEND_TEST_SCENARIO_PARAM_FACTS_SCHEMA_ID = "backend-test-scenario-param-consistency-facts-v1";
+const factsSchema = z
+    .object({
+    schemaId: z.literal(BACKEND_TEST_SCENARIO_PARAM_FACTS_SCHEMA_ID),
+    phase: z.enum(["initial", "final"]),
+    overallStatus: z.enum(["PASS", "PARTIAL", "FAIL", "UNAVAILABLE"]),
+    repairEligible: z.boolean(),
+    repairAttempt: z.number().int().min(0).max(1),
+    strictScenarioParamGate: z.boolean(),
+    entries: z.array(z
+        .object({
+        caseId: z.string(),
+        tpId: z.string(),
+        field: z.string().optional(),
+        intent: z.string(),
+        observed: z.string(),
+        status: z.enum(["MATCH", "MISMATCH", "UNDETERMINED"]),
+        repairability: z.enum([
+            "repairable",
+            "blocked",
+            "none",
+            "undetermined-no-repair",
+        ]),
+        suggestedFix: z.string().optional(),
+        scriptPath: z.string().optional(),
+        bound: z.number().optional(),
+        example: z.string().optional(),
+    })
+        .strict()),
+    assetHashes: z.array(z.object({ path: z.string(), sha256: z.string() }).strict()),
+    summary: z
+        .object({
+        matchCount: z.number().int().min(0),
+        mismatchCount: z.number().int().min(0),
+        undeterminedCount: z.number().int().min(0),
+        repairableCount: z.number().int().min(0),
+        blockedCount: z.number().int().min(0),
+    })
+        .strict(),
+})
+    .strict();
+const CLOSED_SET = new Set([
+    "empty",
+    "missing",
+    "null",
+    "min-1",
+    "min",
+    "max",
+    "max+1",
+    "pattern-invalid",
+    "enum-invalid",
+    "wrong-type",
+    "nominal",
+]);
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function orderedUnique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function sectionBody(body, headings) {
+    for (const heading of headings) {
+        const match = new RegExp(`^###\\s+${heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$([\\s\\S]*?)(?=^###\\s+|$)`, "mi").exec(body);
+        if (match)
+            return match[1] ?? "";
+    }
+    return "";
+}
+async function listMarkdownCases(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const root = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
+    if (!(await exists(root)))
+        return [];
+    const files = (await readdir(root)).filter((name) => name.toLowerCase().endsWith(".md") && name.toLowerCase() !== "readme.md");
+    const cases = [];
+    for (const name of files) {
+        const rel = path.posix.join(resolved.markdownDir, name);
+        const markdown = await readFile(path.join(workspaceRoot, rel), "utf8");
+        const headings = [...markdown.matchAll(/^##\s+(BE-[A-Z0-9_-]+-\d{2,3})\b.*$/gm)];
+        for (let index = 0; index < headings.length; index += 1) {
+            const heading = headings[index];
+            const caseId = heading[1];
+            const body = markdown.slice(heading.index, headings[index + 1]?.index ?? markdown.length);
+            const allPoints = orderedUnique(body.match(/\bTP-[A-Z0-9-]+\b/g) ?? []);
+            const variantLabel = body.match(/(?:Variant Test Points|\u53d8\u4f53\u6d4b\u8bd5\u70b9)\s*[:：]\s*([^\n]+)/i)?.[1] ??
+                "";
+            const variantLabelDeclared = variantLabel.trim().length > 0;
+            const variantLabelIsNone = /^(?:none|无|n\/a|not-applicable)\b/i.test(variantLabel.trim());
+            const variantFromLabel = orderedUnique((variantLabel.match(/\bTP-[A-Z0-9-]+\b/g) ?? []).filter((item) => item.toUpperCase() !== "NONE"));
+            const variantTestPoints = variantLabelIsNone
+                ? []
+                : variantFromLabel.length > 0
+                    ? variantFromLabel
+                    : variantLabelDeclared
+                        ? []
+                        : allPoints.filter((tp) => /(EMPTY|MISSING|NULL|MIN|MAX|INVALID|WRONG|ENUM|PATTERN|NOMINAL|BOUNDARY)/i.test(tp));
+            const scriptLine = body.match(/^(?:\s*[-*+]\s*)?(?:脚本|script)\s*[:：]\s*([^\n]+)/im)?.[1]?.replaceAll("`", "").trim() ?? "";
+            const scriptExplicitNone = /^(?:none|无|n\/a|not-applicable)(?:\s*[（(].*[）)])?$/i.test(scriptLine);
+            const scriptMatch = body.match(new RegExp(`\\\`?(${resolved.scriptDir.replaceAll(/[.*+?^[\]{}()|$]/g, "\\$&")}/[A-Za-z0-9_./-]*test_[A-Za-z0-9_.-]*\\.py)\\\`?`, "i"));
+            cases.push({
+                caseId,
+                body,
+                markdownPath: rel,
+                variantTestPoints: variantLabelDeclared
+                    ? variantTestPoints
+                    : variantTestPoints.length > 0 ? variantTestPoints : allPoints.slice(0, 1),
+                scriptPath: scriptExplicitNone
+                    ? undefined
+                    : scriptMatch?.[1] ?? expectedBackendTestPytestScriptForMarkdownModule(name, resolved),
+            });
+        }
+    }
+    return cases;
+}
+function parseScenarioBoundToken(raw) {
+    if (!raw)
+        return undefined;
+    const token = raw.trim();
+    if (!token || /^LEN<nominal>$/i.test(token) || /^NOMINAL$/i.test(token)) {
+        return undefined;
+    }
+    const direct = Number(token);
+    if (Number.isFinite(direct) && direct >= 0)
+        return direct;
+    const len = /^(?:LEN(?:GTH)?[_-]?)?(\d{1,5})$/i.exec(token);
+    if (len) {
+        const n = Number(len[1]);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    return undefined;
+}
+function parseScenarioIntentLine(line) {
+    // Target may contain commas (body.title,body.status). Intent may contain `|` / spaces.
+    // Stop field values only at known trailing keys or end-of-line.
+    const precise = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;]\s*operation\s*=\s*([^;\n]+?)\s*[|;]\s*target\s*=\s*([^;\n]+?)\s*[|;]\s*intent\s*=\s*([^;\n]+?)(?:\s*[|;]\s*bound\s*=\s*([^\s;|\n]+))?(?:\s*[|;]\s*example\s*=\s*([^;\n]+))?(?:\s*[|;]\s*expectedCode\s*=\s*[^;\n]+)?\s*$/i.exec(line.trim());
+    if (precise) {
+        return {
+            tpId: precise[1],
+            rawIntent: (precise[4] ?? "unknown").trim(),
+            target: precise[3]?.trim(),
+            bound: parseScenarioBoundToken(precise[5]),
+            example: precise[6]?.trim(),
+            legacy: false,
+        };
+    }
+    const legacy = /场景意图\s*[:：]\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*([^\s;|,，\n]+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(line.trim());
+    if (legacy) {
+        return {
+            rawIntent: (legacy[1] ?? "unknown").trim(),
+            field: legacy[2],
+            bound: parseScenarioBoundToken(legacy[3]),
+            example: legacy[4]?.trim(),
+            legacy: true,
+        };
+    }
+    return undefined;
+}
+function resolveScenarioIntentField(target, field) {
+    if (field)
+        return field;
+    if (!target || target === "request")
+        return undefined;
+    const bodyTargets = target
+        .split(/\s*,\s*/)
+        .map((item) => item.trim())
+        .filter((item) => /^(?:body|json|payload)\./i.test(item));
+    const preferred = bodyTargets.find((item) => /\.status$/i.test(item)) ??
+        bodyTargets[0] ??
+        target.split(/\s*,\s*/)[0];
+    return preferred?.split(".").at(-1);
+}
+function resolveCustomLiteralIntent(rawIntent, field) {
+    const lower = rawIntent.toLowerCase();
+    if (!lower.startsWith("custom-literal:")) {
+        return CLOSED_SET.has(lower) ? lower : "unknown";
+    }
+    // Preserve literal case: enum values such as ACTIVE must not be lowercased.
+    const prefixLength = rawIntent.toLowerCase().startsWith("custom-literal:")
+        ? rawIntent.indexOf(":") + 1
+        : "custom-literal:".length;
+    const payload = rawIntent.slice(prefixLength);
+    if (!payload.includes("|") && !payload.includes(",")) {
+        return `custom-literal:${payload}`;
+    }
+    const parts = payload.split(/\s*[|,]\s*/).map((item) => item.trim()).filter(Boolean);
+    if (field) {
+        const byField = parts.find((part) => part.toLowerCase().startsWith(`${field.toLowerCase()}=`));
+        if (byField) {
+            return `custom-literal:${byField.slice(field.length + 1)}`;
+        }
+        if (/^status$/i.test(field)) {
+            const enumLike = parts.find((part) => /^(?:ACTIVE|ARCHIVED|INACTIVE|DISABLED|ENABLED)$/i.test(part));
+            if (enumLike)
+                return `custom-literal:${enumLike}`;
+        }
+        if (/^title$/i.test(field)) {
+            const titleLike = parts.find((part) => !/^(?:ACTIVE|ARCHIVED|INACTIVE|DISABLED|ENABLED)$/i.test(part));
+            if (titleLike)
+                return `custom-literal:${titleLike}`;
+        }
+    }
+    return parts.length === 1
+        ? `custom-literal:${parts[0]}`
+        : "unknown";
+}
+export function inferScenarioParamIntent(input) {
+    const { tpId, caseBody } = input;
+    const intentLines = caseBody
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /场景意图\s*[:：]/.test(line));
+    const parsedLines = intentLines
+        .map((line) => parseScenarioIntentLine(line))
+        .filter((item) => Boolean(item));
+    const preciseForTp = parsedLines.find((item) => item.tpId && item.tpId.toUpperCase() === tpId.toUpperCase());
+    const legacyLine = parsedLines.find((item) => item.legacy);
+    const fallbackLine = new RegExp(`${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,200}?intent\\s*[=:]\\s*([^|;,\uff0c\\n]+)`, "i").exec(caseBody);
+    const machine = preciseForTp ??
+        (legacyLine && parsedLines.filter((item) => !item.legacy).length === 0 ? legacyLine : undefined) ??
+        (fallbackLine
+            ? {
+                rawIntent: fallbackLine[1] ?? "unknown",
+                legacy: true,
+            }
+            : undefined);
+    if (machine) {
+        const field = resolveScenarioIntentField(machine.target, machine.field);
+        const rawIntent = machine.rawIntent.trim();
+        const example = machine.example;
+        const lower = rawIntent.toLowerCase();
+        let normalizedIntent = lower === "nominal-operation" ? "nominal" : lower;
+        // Writers sometimes mark a short "typical" length sample as min/max with bound=LEN<nominal>.
+        // Treat that as nominal so a short helper/string is not forced to equal maxLength.
+        if ((normalizedIntent === "min" || normalizedIntent === "max") &&
+            /NOMINAL/i.test(tpId)) {
+            normalizedIntent = "nominal";
+        }
+        const dataSection = sectionBody(caseBody, ["测试数据", "Test Data", "操作步骤", "Steps"]);
+        const haystack = `${caseBody}\n${dataSection}`;
+        const fieldEsc = field
+            ? field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+            : undefined;
+        const maxBoundFromBody = fieldEsc
+            ? new RegExp(`${fieldEsc}[^\\n]{0,80}?(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})`, "i").exec(haystack) ??
+                new RegExp(`(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})[^\\n]{0,80}?${fieldEsc}`, "i").exec(haystack) ??
+                /(?:maxLength|max(?:imum)?|上限|最大长度)\s*[=:：]?\s*(\d{1,4})/i.exec(haystack)
+            : /(?:maxLength|max(?:imum)?|上限|最大长度)\s*[=:：]?\s*(\d{1,4})/i.exec(haystack);
+        const minBoundFromBody = fieldEsc
+            ? new RegExp(`${fieldEsc}[^\\n]{0,80}?(?:minLength|min(?:imum)?|下限|最小长度)\\s*[=:：]?\\s*(\\d{1,4})`, "i").exec(haystack) ??
+                new RegExp(`(?:minLength|min(?:imum)?|下限|最小长度)\\s*[=:：]?\\s*(\\d{1,4})[^\\n]{0,80}?${fieldEsc}`, "i").exec(haystack) ??
+                /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(haystack)
+            : /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(haystack);
+        const prefersMinBound = normalizedIntent === "min" ||
+            normalizedIntent === "min-1" ||
+            /(?:MIN|LEN1|LENGTH-?1|最短|最小)/i.test(tpId);
+        const boundFromBody = prefersMinBound
+            ? minBoundFromBody ?? maxBoundFromBody
+            : maxBoundFromBody ?? minBoundFromBody;
+        const boundFromTp = /(?:LEN(?:GTH)?|长度)[_-]?(\d{1,5})(?:[_-]|$)/i.exec(tpId) ??
+            /(?:MIN|MAX)[_-]?(\d{1,5})(?:[_-]|$)/i.exec(tpId);
+        const lengthIntent = normalizedIntent === "min" ||
+            normalizedIntent === "min-1" ||
+            normalizedIntent === "max" ||
+            normalizedIntent === "max+1";
+        // Length intents: explicit machine bound >0, then TP-encoded LEN1/LEN100,
+        // then field min/maxLength. Prevents maxLength=100 shadowing min/LEN1.
+        const boundFromTpNumber = boundFromTp ? Number(boundFromTp[1]) : undefined;
+        // max+1 TP tokens encode the oversized length (LEN101), so convert to base bound.
+        const boundFromTpNormalized = boundFromTpNumber === undefined
+            ? undefined
+            : normalizedIntent === "max+1"
+                ? Math.max(0, boundFromTpNumber - 1)
+                : boundFromTpNumber;
+        const bound = machine.bound && machine.bound > 0
+            ? machine.bound
+            : lengthIntent && boundFromTpNormalized !== undefined
+                ? boundFromTpNormalized
+                : boundFromBody
+                    ? Number(boundFromBody[1])
+                    : machine.bound;
+        if (rawIntent.toLowerCase().startsWith("custom-literal:")) {
+            const resolved = resolveCustomLiteralIntent(rawIntent, field);
+            const rawLiteral = rawIntent.slice(rawIntent.indexOf(":") + 1).trim();
+            const intent = resolved === "unknown" && example && rawLiteral === example.trim()
+                ? `custom-literal:${example.trim()}`
+                : resolved;
+            return {
+                intent,
+                field,
+                bound,
+                example,
+                intentSource: "machine-line",
+            };
+        }
+        return {
+            intent: (CLOSED_SET.has(normalizedIntent) ? normalizedIntent : "unknown"),
+            field,
+            bound,
+            example,
+            intentSource: "machine-line",
+        };
+    }
+    const upper = tpId.toUpperCase();
+    const fieldFromTp = tpId
+        .replace(/^TP-/i, "")
+        .split("-")
+        .filter((part) => ![
+        "EMPTY",
+        "MISSING",
+        "NULL",
+        "MIN",
+        "MAX",
+        "PLUS",
+        "1",
+        "INVALID",
+        "WRONG",
+        "TYPE",
+        "ENUM",
+        "PATTERN",
+        "NOMINAL",
+        "BOUNDARY",
+        "CASE",
+        "VARIANT",
+        "WHITESPACE",
+        "UNKNOWN",
+        "HEALTH",
+        "UP",
+        "OK",
+        "GET",
+        "API",
+        "STATUS",
+        "CODE",
+        "HTTP",
+        "RESPONSE",
+        "REQUEST",
+        "NOTES",
+        "NOTE",
+        "REQUIRED",
+        "LENGTH",
+        "OVER",
+        "FILTER",
+        "LIST",
+        "ROUNDTRIP",
+        "READINESS",
+        "DEFAULT",
+        "TRIM",
+        "BLANK",
+        "WHITESPACE",
+        "NORMALIZE",
+        "FAIL",
+        "SUCCESS",
+        "LOWERCASE",
+        "UPPERCASE",
+    ].includes(part.toUpperCase()))[0]
+        ?.replace(/_/g, "") ?? undefined;
+    const field = fieldFromTp && fieldFromTp.length > 1
+        ? fieldFromTp.charAt(0).toLowerCase() + fieldFromTp.slice(1)
+        : undefined;
+    const dataSection = sectionBody(caseBody, ["测试数据", "Test Data", "操作步骤", "Steps"]);
+    const fieldScopedBound = field
+        ? new RegExp(`${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,80}?(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})`, "i").exec(`${caseBody}\n${dataSection}`) ??
+            new RegExp(`(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})[^\\n]{0,80}?${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i").exec(`${caseBody}\n${dataSection}`)
+        : undefined;
+    const boundMatch = fieldScopedBound ??
+        /(?:maxLength|max(?:imum)?|上限|最大长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`) ??
+        /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`);
+    const bound = boundMatch ? Number(boundMatch[1]) : undefined;
+    const exampleMatch = /(?:反例|invalid example|example)\s*[=:：]\s*[`"]?([^`"\n]+)[`"]?/i.exec(caseBody);
+    const example = exampleMatch?.[1]?.trim();
+    if (/EMPTY|空白|空串|空字符串/.test(upper) || /空字符串|空串|empty string/i.test(caseBody)) {
+        return { intent: "empty", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/MISSING|缺省|缺失|省略/.test(upper) || /缺少字段|缺失字段|missing field/i.test(caseBody)) {
+        return { intent: "missing", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/\bNULL\b|空值/.test(upper) || /\bnull\b/i.test(caseBody)) {
+        return { intent: "null", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/MAX[-_]?PLUS[-_]?1|MAX\+1|超长|越界|LENGTH[-_]?OVER|OVER[-_]?LENGTH|OVER/.test(upper)) {
+        return { intent: "max+1", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/\bMAX\b|最大/.test(upper)) {
+        return { intent: "max", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/MIN[-_]?1|最小减|min-1/i.test(upper)) {
+        return { intent: "min-1", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/\bMIN\b|最小/.test(upper)) {
+        return { intent: "min", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/WRONG[-_]?TYPE|类型错误/.test(upper)) {
+        return { intent: "wrong-type", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/ENUM.*INVALID|INVALID.*ENUM|非法枚举/.test(upper)) {
+        return { intent: "enum-invalid", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/PATTERN|FORMAT|UPPERCASE|大写|非法格式/.test(upper)) {
+        return { intent: "pattern-invalid", field, bound, example, intentSource: "tp-fallback" };
+    }
+    if (/NOMINAL|正常|合法|主路径|SUCCESS/.test(upper)) {
+        return { intent: "nominal", field, bound, example, intentSource: "tp-fallback" };
+    }
+    return { intent: "unknown", field, bound, example, intentSource: "tp-fallback" };
+}
+const OMIT_SENTINEL_RE = /^(?:_OMIT|OMIT|MISSING|Ellipsis|\.\.\.)\b/;
+const HTTP_EXPECTED_CODE_RE = /^(?:2xx|3xx|4xx|5xx|[1-5]\d{2}|HTTP_[1-5]\d{2})$/i;
+/** Semantic custom-literal tokens that describe a value class, not a raw string. */
+function isWhitespaceSemanticLiteral(token) {
+    return /^(?:whitespace-only|ws-only|blank|blank-only|spaces-only|space-only|two-spaces|multiple-spaces|empty-ws|empty-whitespace)$/i.test(token.trim());
+}
+function isWhitespacePaddedSemanticLiteral(token) {
+    return /^(?:whitespace-padded|ws-padded|padded-whitespace|leading-trailing-ws|trim-target|trim|trimmed|pad|padded)$/i.test(token.trim());
+}
+function isWhitespaceOnlyString(value) {
+    return value.length > 0 && /^\s+$/.test(value);
+}
+function isWhitespacePaddedString(value) {
+    return value.length > 0 && value !== value.trim() && value.trim().length > 0;
+}
+function normalizeScenarioLiteralText(value) {
+    // Writers sometimes emit visible-space placeholders (U+2420), NBSP variants,
+    // or URL-encoded spaces in machine-readable Markdown.
+    const normalized = value
+        .replace(/␠/g, " ")
+        .replace(/ /g, " ")
+        .replace(/ /g, " ")
+        .replace(/ /g, " ");
+    try {
+        return /%[0-9A-F]{2}/i.test(normalized) ? decodeURIComponent(normalized) : normalized;
+    }
+    catch {
+        return normalized;
+    }
+}
+function stripWrappingQuotes(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2)) {
+        return trimmed.slice(1, -1);
+    }
+    return value;
+}
+function normalizeCustomLiteralExpected(raw) {
+    return normalizeScenarioLiteralText(stripWrappingQuotes(raw));
+}
+function isHttpExpectedCodeLiteral(value) {
+    return HTTP_EXPECTED_CODE_RE.test(value.trim());
+}
+/** Decode common Python string escapes found in source text (not JSON). */
+function unescapePythonStringLiteral(value) {
+    return value
+        .replace(/\\n/g, "\n")
+        .replace(/\\t/g, "\t")
+        .replace(/\\r/g, "\r")
+        .replace(/\\'/g, "'")
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, "\\");
+}
+function featuresFromStringValue(value) {
+    const decoded = normalizeScenarioLiteralText(unescapePythonStringLiteral(value));
+    return {
+        kind: decoded.length === 0 ? "empty-string" : "string",
+        text: JSON.stringify(decoded),
+        length: decoded.length,
+        hasUppercase: /[A-Z]/.test(decoded),
+        literal: decoded,
+    };
+}
+function collectPythonStringConstants(source) {
+    const constants = new Map();
+    const re = /\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(["'])([^"'\\]*)\2/g;
+    let match;
+    while ((match = re.exec(source)) !== null) {
+        const name = match[1] ?? "";
+        const value = match[3] ?? "";
+        if (name && !constants.has(name))
+            constants.set(name, value);
+    }
+    return constants;
+}
+function resolveNamedConstant(name, constants) {
+    if (!constants?.has(name))
+        return undefined;
+    const value = constants.get(name) ?? "";
+    return featuresFromStringValue(value);
+}
+function observeLiteralToken(raw, field, constants) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    if (OMIT_SENTINEL_RE.test(trimmed) || trimmed === "...") {
+        return {
+            kind: "missing-key",
+            text: field ? `missing:${field}` : "missing-key",
+        };
+    }
+    if (trimmed === "None" || trimmed === "null") {
+        return { kind: "none", text: "None", literal: "None" };
+    }
+    if (trimmed === '""' || trimmed === "''") {
+        return { kind: "empty-string", text: '""', length: 0, literal: "" };
+    }
+    const repeatedValue = /^(['"])([^'"\\])\1\s*\*\s*(\d{1,5})$/.exec(trimmed);
+    if (repeatedValue) {
+        const ch = repeatedValue[2] ?? "x";
+        const length = Number(repeatedValue[3] ?? "0");
+        const value = ch.repeat(Math.max(0, length));
+        return featuresFromStringValue(value);
+    }
+    // "x" * _TITLE_MAX_LENGTH / "a" * _TITLE_LEN100
+    const repeatedConst = /^(['"])([^'"\\])\1\s*\*\s*([A-Za-z_][A-Za-z0-9_]*)$/.exec(trimmed);
+    if (repeatedConst) {
+        const helper = repeatedConst[3] ?? "";
+        const fromConst = resolveNamedConstant(helper, constants);
+        if (fromConst?.kind === "string" && typeof fromConst.length === "number") {
+            return {
+                kind: "number",
+                text: trimmed,
+                length: fromConst.length,
+                literal: String(fromConst.length),
+            };
+        }
+        const lenFromName = /(?:^|_)LEN(?:GTH)?_?(\d{1,5})$/i.exec(helper) ??
+            /LEN(?:GTH)?_?(\d{1,5})$/i.exec(helper);
+        if (lenFromName) {
+            const length = Number(lenFromName[1] ?? "0");
+            return { kind: "number", text: trimmed, length, literal: String(length) };
+        }
+        if (/(?:OVER|OVERSIZE|TOO[_-]?LONG|MAX[_-]?PLUS[_-]?1|MAXPLUS1)/i.test(helper)) {
+            return { kind: "name", text: helper, length: -2, literal: "oversize-helper" };
+        }
+        if (/(?:MAX[_-]?LENGTH|LENGTH[_-]?MAX|_MAX_LEN(?:GTH)?$)/i.test(helper)) {
+            return { kind: "name", text: helper, length: -1, literal: "max-length-helper" };
+        }
+        if (/(?:MIN[_-]?LENGTH|LENGTH[_-]?MIN|_MIN_LEN(?:GTH)?$)/i.test(helper)) {
+            return { kind: "name", text: helper, length: -3, literal: "min-length-helper" };
+        }
+    }
+    const triple = /^("""|''')([\s\S]*)\1$/.exec(trimmed);
+    if (triple) {
+        return featuresFromStringValue(triple[2] ?? "");
+    }
+    const str = /^['"]([\s\S]*)['"]$/.exec(trimmed);
+    if (str) {
+        return featuresFromStringValue(str[1] ?? "");
+    }
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+        return { kind: "number", text: trimmed, literal: trimmed };
+    }
+    if (trimmed === "True" || trimmed === "False") {
+        return { kind: "boolean", text: trimmed, literal: trimmed };
+    }
+    if (trimmed.startsWith("[")) {
+        const inner = trimmed.replace(/^\[/, "").replace(/\]$/, "").trim();
+        let count = 0;
+        let depth = 0;
+        let quote = "";
+        let escaped = false;
+        if (inner) {
+            count = 1;
+            for (const ch of inner) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (ch === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (quote) {
+                    if (ch === quote)
+                        quote = "";
+                    continue;
+                }
+                if (ch === '"' || ch === "'") {
+                    quote = ch;
+                    continue;
+                }
+                if (ch === "[" || ch === "{" || ch === "(")
+                    depth += 1;
+                else if (ch === "]" || ch === "}" || ch === ")")
+                    depth -= 1;
+                else if (ch === "," && depth === 0)
+                    count += 1;
+            }
+        }
+        return { kind: "list", text: trimmed, length: count };
+    }
+    if (trimmed.startsWith("{"))
+        return { kind: "dict", text: trimmed };
+    if (/\(/.test(trimmed)) {
+        // Tuple/list positional wrappers: (_TITLE_LEN1, "2xx") → first meaningful token.
+        const inner = trimmed.replace(/^\(/, "").replace(/\)$/, "");
+        const first = inner.split(",")[0]?.trim();
+        if (first && first !== trimmed) {
+            return observeLiteralToken(first, field, constants);
+        }
+        return { kind: "call", text: trimmed };
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed)) {
+        if (OMIT_SENTINEL_RE.test(trimmed)) {
+            return {
+                kind: "missing-key",
+                text: field ? `missing:${field}` : "missing-key",
+            };
+        }
+        // Length helper names used by writers:
+        // _TITLE_LEN1 / _CONTENT_LEN2000 / _TITLE_MAX_LENGTH / _CONTENT_OVER_LENGTH
+        const lenFromName = /(?:^|_)LEN(?:GTH)?_?(\d{1,5})$/i.exec(trimmed) ??
+            /LEN(?:GTH)?_?(\d{1,5})$/i.exec(trimmed);
+        if (lenFromName) {
+            const length = Number(lenFromName[1] ?? "0");
+            return {
+                kind: "number",
+                text: trimmed,
+                length,
+                literal: String(length),
+            };
+        }
+        // Opaque max/min/oversize helpers resolve against Markdown bound in compareIntent.
+        if (/(?:OVER|OVERSIZE|TOO[_-]?LONG|MAX[_-]?PLUS[_-]?1|MAXPLUS1)/i.test(trimmed)) {
+            return { kind: "name", text: trimmed, length: -2, literal: "oversize-helper" };
+        }
+        if (/(?:MAX[_-]?LENGTH|LENGTH[_-]?MAX|_MAX_LEN(?:GTH)?$)/i.test(trimmed)) {
+            return { kind: "name", text: trimmed, length: -1, literal: "max-length-helper" };
+        }
+        if (/(?:MIN[_-]?LENGTH|LENGTH[_-]?MIN|_MIN_LEN(?:GTH)?$)/i.test(trimmed)) {
+            return { kind: "name", text: trimmed, length: -3, literal: "min-length-helper" };
+        }
+        const resolved = resolveNamedConstant(trimmed, constants);
+        if (resolved)
+            return resolved;
+        return { kind: "name", text: trimmed };
+    }
+    return { kind: "unknown", text: trimmed };
+}
+export function extractPytestParamBlock(source, tpId) {
+    const idPattern = new RegExp(`id\\s*=\\s*["']${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`);
+    const matches = [...source.matchAll(/pytest\.param\s*\(/g)];
+    for (const match of matches) {
+        const start = match.index ?? 0;
+        let depth = 0;
+        let end = -1;
+        for (let i = start; i < source.length; i += 1) {
+            const ch = source[i];
+            if (ch === "(")
+                depth += 1;
+            else if (ch === ")") {
+                depth -= 1;
+                if (depth === 0) {
+                    end = i + 1;
+                    break;
+                }
+            }
+        }
+        if (end < 0)
+            continue;
+        const block = source.slice(start, end);
+        if (idPattern.test(block))
+            return block;
+    }
+    return undefined;
+}
+function extractPytestParamParameterNames(source, tpId) {
+    const block = extractPytestParamBlock(source, tpId);
+    if (!block)
+        return [];
+    const blockIndex = source.indexOf(block);
+    if (blockIndex < 0)
+        return [];
+    const decoratorIndex = source.lastIndexOf("@pytest.mark.parametrize", blockIndex);
+    if (decoratorIndex < 0)
+        return [];
+    const prefix = source.slice(decoratorIndex, blockIndex);
+    const match = /@pytest\.mark\.parametrize\s*\(\s*["']([^"']+)["']/s.exec(prefix);
+    return match?.[1]?.split(",").map((name) => name.trim()).filter(Boolean) ?? [];
+}
+export function observeParamFeatures(block, field, constants, parameterNames) {
+    if (!block)
+        return { kind: "unknown", text: "param-block-missing" };
+    const compact = block.replace(/\s+/g, " ");
+    if (/\bFaker\b|\bfake\b|\brandom\b|\buuid4\b|\bfactory\b/i.test(block)) {
+        return { kind: "call", text: "dynamic-or-faker" };
+    }
+    // Prefer dict-like payload extraction when a real object literal is present.
+    // Writers often build the payload in the test body and only pass scalar intent
+    // values in pytest.param; in that case fall through to positional observation.
+    const dictMatch = /\{\s*([\s\S]*?)\s*\}/.exec(block) ??
+        /(?:payload|body|data|json)\s*=\s*(\{[\s\S]*?\})/.exec(block);
+    const dictText = dictMatch?.[0] ?? dictMatch?.[1] ?? "";
+    const fieldPattern = field
+        ? new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:`)
+        : undefined;
+    const dictHasField = Boolean(fieldPattern && fieldPattern.test(dictText));
+    const dictLooksLikePayload = Boolean(dictMatch) &&
+        (/["'][A-Za-z_][A-Za-z0-9_]*["']\s*:/.test(dictText) ||
+            /(?:payload|body|data|json)\s*=/.test(block));
+    if (dictLooksLikePayload && !field) {
+        return { kind: "dict", text: dictText.replace(/\s+/g, " ").slice(0, 160) };
+    }
+    if (dictLooksLikePayload && field) {
+        if (!dictHasField) {
+            return { kind: "missing-key", text: `missing:${field}` };
+        }
+        const valueMatch = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*([^,}\n]+)`).exec(dictText);
+        const raw = valueMatch?.[1]?.trim() ?? "";
+        return (observeLiteralToken(raw, field, constants) ?? {
+            kind: "unknown",
+            text: raw || compact.slice(0, 120),
+        });
+    }
+    // Repeated string literal: "a" * 100 / 'x'*101
+    const repeated = /pytest\.param\s*\(\s*(["'])([^"'\\])\1\s*\*\s*(\d{1,5})/.exec(block) ??
+        /(["'])([^"'\\])\1\s*\*\s*(\d{1,5})/.exec(block);
+    if (repeated && (!field || !/\{/.test(block))) {
+        const ch = repeated[2] ?? "x";
+        const length = Number(repeated[3] ?? "0");
+        const value = ch.repeat(Math.max(0, length));
+        return {
+            kind: length === 0 ? "empty-string" : "string",
+            text: JSON.stringify(value),
+            length,
+            hasUppercase: /[A-Z]/.test(value),
+            literal: value,
+        };
+    }
+    // Bare omit sentinel before id=...
+    if (/pytest\.param\s*\(\s*(?:_OMIT|OMIT|MISSING|\.\.\.|Ellipsis)\s*(?:,|\)|$)/.test(block)) {
+        return {
+            kind: "missing-key",
+            text: field ? `missing:${field}` : "missing-key",
+        };
+    }
+    // Parse top-level positional args before the legacy token scanner so list
+    // cardinality and field/value rows remain statically visible.
+    const topLevelArgs = (() => {
+        const open = block.indexOf("(");
+        const close = block.lastIndexOf(")");
+        if (open < 0 || close <= open)
+            return [];
+        const input = block.slice(open + 1, close);
+        const args = [];
+        let start = 0;
+        let depth = 0;
+        let quote = "";
+        let escaped = false;
+        for (let i = 0; i < input.length; i += 1) {
+            const ch = input[i];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (quote) {
+                if (ch === quote)
+                    quote = "";
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                quote = ch;
+                continue;
+            }
+            if (ch === "[" || ch === "{" || ch === "(")
+                depth += 1;
+            else if (ch === "]" || ch === "}" || ch === ")")
+                depth -= 1;
+            else if (ch === "," && depth === 0) {
+                args.push(input.slice(start, i).trim());
+                start = i + 1;
+            }
+        }
+        args.push(input.slice(start).trim());
+        return args.filter((arg) => arg && !/^(?:id|marks)\s*=/.test(arg));
+    })();
+    if (topLevelArgs.length > 0) {
+        const idTp = /\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/i.exec(block)?.[1]?.toUpperCase();
+        const meaningfulArgs = topLevelArgs.filter((arg) => {
+            const value = observeLiteralToken(arg, field, constants);
+            if (value?.kind !== "string" || !value.literal)
+                return true;
+            if (/^TP-[A-Z0-9-]+$/i.test(value.literal) && (!idTp || value.literal.toUpperCase() === idTp))
+                return false;
+            if (isHttpExpectedCodeLiteral(value.literal))
+                return false;
+            return true;
+        });
+        if (meaningfulArgs.length === 0 && field) {
+            return { kind: "missing-key", text: `missing:${field}` };
+        }
+        let candidateIndex = field
+            ? Math.max(0, parameterNames?.findIndex((name) => name.toLowerCase() === field.toLowerCase()) ?? -1)
+            : 0;
+        const first = meaningfulArgs[0]
+            ? observeLiteralToken(meaningfulArgs[0], field, constants)
+            : undefined;
+        if (field && parameterNames?.some((name) => /^(?:field|key|field_name|missing_field|missing_key|omit_field)$/i.test(name)) &&
+            !parameterNames.some((name) => /^(?:value|field_value|payload_value)$/i.test(name))) {
+            if (first?.kind === "string" && first.literal?.toLowerCase() === field.toLowerCase()) {
+                return { kind: "missing-key", text: `missing:${field}` };
+            }
+        }
+        if (field &&
+            first?.kind === "string" &&
+            first.literal?.toLowerCase() === field.toLowerCase() &&
+            meaningfulArgs.length > 1) {
+            candidateIndex = 1;
+        }
+        const rawCandidate = meaningfulArgs[candidateIndex];
+        const candidate = rawCandidate
+            ? observeLiteralToken(rawCandidate, field, constants)
+            : undefined;
+        if (candidate?.kind === "none" && parameterNames) {
+            const omitIndex = parameterNames.findIndex((name) => /^(?:omit|omitted|is_omit|should_omit)$/i.test(name));
+            if (omitIndex >= 0 && /^True$/.test(topLevelArgs[omitIndex] ?? "")) {
+                return { kind: "missing-key", text: field ? `missing:${field}` : "missing-key" };
+            }
+        }
+        if (candidate)
+            return candidate;
+    }
+    // Positional args: skip a leading TP-id label when writers emit
+    // pytest.param("TP-...", actual_value, id="TP-...").
+    // Also skip HTTP expected-code tokens (2xx/400) that are not field values.
+    const paramOpen = /pytest\.param\s*\(/.exec(block);
+    if (paramOpen) {
+        const afterOpen = block.slice((paramOpen.index ?? 0) + paramOpen[0].length);
+        const positionalTokens = [];
+        const tokenRe = /\s*(_OMIT|OMIT|MISSING|Ellipsis|\.\.\.|None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'|(?:["'][^"'\\]["']\s*\*\s*(?:\d{1,5}|[A-Za-z_][A-Za-z0-9_]*))|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[A-Za-z_][A-Za-z0-9_]*)\s*(?:,|\)|$)/g;
+        let match;
+        while ((match = tokenRe.exec(afterOpen)) !== null) {
+            const between = afterOpen.slice(0, match.index);
+            if (/(?:^|,)\s*(?:id|marks)\s*=/.test(between + match[0]))
+                break;
+            if (/^(?:id|marks)$/i.test(match[1] ?? ""))
+                break;
+            positionalTokens.push(match[1]);
+            if (positionalTokens.length >= 6)
+                break;
+        }
+        const idMatch = /\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/i.exec(block);
+        const idTp = idMatch?.[1]?.toUpperCase();
+        const candidates = positionalTokens.filter((raw) => {
+            const observed = observeLiteralToken(raw, field, constants);
+            if (!observed)
+                return false;
+            if (observed.kind === "string" &&
+                observed.literal &&
+                /^TP-[A-Z0-9-]+$/i.test(observed.literal) &&
+                (!idTp || observed.literal.toUpperCase() === idTp)) {
+                return false;
+            }
+            // Only drop string expected-code tokens ("2xx"/"400"). Bare numbers stay
+            // because they are commonly length bounds (e.g. 100 for maxLength).
+            if (observed.kind === "string" &&
+                observed.literal &&
+                isHttpExpectedCodeLiteral(observed.literal)) {
+                return false;
+            }
+            return true;
+        });
+        const raw = candidates[0];
+        if (raw) {
+            return (observeLiteralToken(raw, field, constants) ?? {
+                kind: "unknown",
+                text: raw,
+            });
+        }
+        // Only expected-code / TP-label tokens remain -> treat as omitted field value.
+        if (positionalTokens.length > 0 && field) {
+            return { kind: "missing-key", text: `missing:${field}` };
+        }
+    }
+    return { kind: "unknown", text: compact.slice(0, 160) };
+}
+function observedLengthValue(observed) {
+    if (observed.kind === "empty-string")
+        return 0;
+    if (observed.kind === "number" && observed.literal !== undefined) {
+        const n = Number(observed.literal);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    if (observed.kind === "list" && typeof observed.length === "number") {
+        return observed.length;
+    }
+    if (observed.kind === "string") {
+        // Bare digit strings in pytest.param are length tokens, not character payloads.
+        if (observed.literal && /^-?\d+$/.test(observed.literal.trim())) {
+            const n = Number(observed.literal.trim());
+            return Number.isFinite(n) ? n : undefined;
+        }
+        return observed.length;
+    }
+    return undefined;
+}
+function isMaxLengthHelper(observed) {
+    return (observed.literal === "max-length-helper" ||
+        (observed.kind === "name" &&
+            /(?:MAX[_-]?LENGTH|LENGTH[_-]?MAX|_MAX_LEN(?:GTH)?$)/i.test(observed.text)));
+}
+function isMinLengthHelper(observed) {
+    return (observed.literal === "min-length-helper" ||
+        (observed.kind === "name" &&
+            /(?:MIN[_-]?LENGTH|LENGTH[_-]?MIN|_MIN_LEN(?:GTH)?$)/i.test(observed.text)));
+}
+function isOversizeLengthHelper(observed) {
+    return (observed.literal === "oversize-helper" ||
+        (observed.kind === "name" &&
+            /(?:OVER|OVERSIZE|TOO[_-]?LONG|MAX[_-]?PLUS[_-]?1|MAXPLUS1)/i.test(observed.text)));
+}
+function compareIntent(intent, observed, bound, example, field) {
+    if (intent === "unknown")
+        return "UNDETERMINED";
+    // Opaque length helpers are resolved below against bound; other names stay undetermined.
+    if (observed.kind === "call" ||
+        (observed.kind === "name" &&
+            !isMaxLengthHelper(observed) &&
+            !isMinLengthHelper(observed) &&
+            !isOversizeLengthHelper(observed))) {
+        return "UNDETERMINED";
+    }
+    switch (intent) {
+        case "empty":
+            // Empty-string samples match; OMIT/DEFAULT writers often use missing-key instead.
+            if (observed.kind === "missing-key")
+                return "MATCH";
+            return observed.kind === "empty-string" ||
+                (observed.kind === "list" && observed.length === 0) ||
+                (observed.kind === "string" &&
+                    (observed.length === 0 ||
+                        (typeof observed.literal === "string" &&
+                            /^\s+$/.test(observed.literal))))
+                ? "MATCH"
+                : observed.kind === "unknown"
+                    ? "UNDETERMINED"
+                    : "MISMATCH";
+        case "missing":
+            return observed.kind === "missing-key"
+                ? "MATCH"
+                : observed.kind === "unknown"
+                    ? "UNDETERMINED"
+                    : "MISMATCH";
+        case "null":
+            return observed.kind === "none"
+                ? "MATCH"
+                : observed.kind === "unknown"
+                    ? "UNDETERMINED"
+                    : "MISMATCH";
+        case "max":
+            if (bound === undefined)
+                return "UNDETERMINED";
+            {
+                if (isMaxLengthHelper(observed))
+                    return "MATCH";
+                const len = observedLengthValue(observed);
+                if (len === bound)
+                    return "MATCH";
+                return len !== undefined ? "MISMATCH" : "UNDETERMINED";
+            }
+        case "max+1":
+            if (bound === undefined)
+                return "UNDETERMINED";
+            {
+                if (isOversizeLengthHelper(observed))
+                    return "MATCH";
+                const len = observedLengthValue(observed);
+                // Accept base+1 or the oversized length itself when bound already is oversized.
+                if (len === bound + 1 || len === bound)
+                    return "MATCH";
+                return len !== undefined ? "MISMATCH" : "UNDETERMINED";
+            }
+        case "min":
+            if (bound === undefined)
+                return "UNDETERMINED";
+            {
+                if (isMinLengthHelper(observed))
+                    return "MATCH";
+                const len = observedLengthValue(observed);
+                if (len === bound)
+                    return "MATCH";
+                return len !== undefined ? "MISMATCH" : "UNDETERMINED";
+            }
+        case "min-1":
+            if (bound === undefined)
+                return "UNDETERMINED";
+            {
+                const expectedMin1 = Math.max(0, bound - 1);
+                const len = observedLengthValue(observed);
+                if (len === expectedMin1)
+                    return "MATCH";
+                return len !== undefined ? "MISMATCH" : "UNDETERMINED";
+            }
+        case "pattern-invalid":
+            if (observed.kind === "string" && example !== undefined) {
+                return observed.literal === example ? "MATCH" : "MISMATCH";
+            }
+            return "UNDETERMINED";
+        case "wrong-type": {
+            // A string can be the deliberate wrong type for an array/number/object
+            // field. Accept it only when the precise machine scenario supplies the
+            // same explicit example; without that evidence keep the conservative
+            // generic string mismatch behavior.
+            const normalizedExample = example?.replace(/^(["'])([\s\S]*)\1$/, "$2");
+            if ((observed.kind === "string" || observed.kind === "empty-string") &&
+                normalizedExample !== undefined &&
+                observed.literal === normalizedExample) {
+                return "MATCH";
+            }
+            return observed.kind === "number" ||
+                observed.kind === "boolean" ||
+                observed.kind === "list" ||
+                observed.kind === "dict" ||
+                (observed.kind === "string" && field === "tags")
+                ? "MATCH"
+                : observed.kind === "string" || observed.kind === "empty-string"
+                    ? "MISMATCH"
+                    : "UNDETERMINED";
+        }
+        case "enum-invalid":
+            // A concrete non-empty invalid enum literal is a valid negative sample.
+            if (observed.kind === "string" && (observed.literal?.length ?? 0) > 0) {
+                return "MATCH";
+            }
+            if (observed.kind === "number" || observed.kind === "boolean") {
+                return "MATCH";
+            }
+            return observed.kind === "unknown" || observed.kind === "missing-key"
+                ? "UNDETERMINED"
+                : "MISMATCH";
+        case "nominal":
+            // Request-level nominal (no body field) may legitimately pass None/empty query filters.
+            if (!field && (observed.kind === "none" || observed.kind === "missing-key")) {
+                return "MATCH";
+            }
+            return observed.kind === "string" ||
+                observed.kind === "number" ||
+                observed.kind === "boolean" ||
+                observed.kind === "dict" ||
+                observed.kind === "list"
+                ? "MATCH"
+                : observed.kind === "empty-string" || observed.kind === "none"
+                    ? "MISMATCH"
+                    : "UNDETERMINED";
+        default:
+            if (intent.startsWith("custom-literal:")) {
+                const expectedRaw = intent.slice("custom-literal:".length);
+                const expected = normalizeCustomLiteralExpected(expectedRaw);
+                const literal = normalizeScenarioLiteralText(observed.literal ?? "");
+                if (field === "id" &&
+                    ((/^create-derived-active-id$/i.test(expected) && literal.toLowerCase() === "create-active") ||
+                        (/^create-delete-derived-id$/i.test(expected) && literal.toLowerCase() === "create-delete"))) {
+                    return "MATCH";
+                }
+                if (isWhitespaceSemanticLiteral(expected) || isWhitespaceOnlyString(expected)) {
+                    return observed.kind === "empty-string" ||
+                        (observed.kind === "string" && isWhitespaceOnlyString(literal))
+                        ? "MATCH"
+                        : observed.kind === "unknown"
+                            ? "UNDETERMINED"
+                            : "MISMATCH";
+                }
+                if (isWhitespacePaddedSemanticLiteral(expected)) {
+                    // trim/padded requires non-empty content after strip; all-whitespace is empty/ws-only.
+                    if (isWhitespaceOnlyString(literal) || observed.kind === "empty-string") {
+                        return "MISMATCH";
+                    }
+                    return observed.kind === "string" && isWhitespacePaddedString(literal)
+                        ? "MATCH"
+                        : observed.kind === "unknown"
+                            ? "UNDETERMINED"
+                            : "MISMATCH";
+                }
+                if (isWhitespacePaddedString(expected)) {
+                    return observed.kind === "string" && literal === expected
+                        ? "MATCH"
+                        : observed.kind === "unknown"
+                            ? "UNDETERMINED"
+                            : "MISMATCH";
+                }
+                return literal === expected
+                    ? "MATCH"
+                    : observed.kind === "unknown"
+                        ? "UNDETERMINED"
+                        : "MISMATCH";
+            }
+            return "UNDETERMINED";
+    }
+}
+function repairabilityFor(status, intent, observed, example) {
+    if (status === "MATCH")
+        return "none";
+    if (status === "UNDETERMINED")
+        return "undetermined-no-repair";
+    if (observed.kind === "call" || observed.kind === "name") {
+        return "undetermined-no-repair";
+    }
+    if (intent === "unknown")
+        return "blocked";
+    if ((intent === "enum-invalid" || intent === "wrong-type") &&
+        !example &&
+        !intent.startsWith("custom-literal:")) {
+        return "blocked";
+    }
+    if (CLOSED_SET.has(intent) || intent.startsWith("custom-literal:")) {
+        return "repairable";
+    }
+    return "blocked";
+}
+function suggestedFixFor(intent, field, bound, example) {
+    if (!field && intent !== "nominal")
+        return undefined;
+    switch (intent) {
+        case "empty":
+            return field ? `set ${field}=""` : 'set value=""';
+        case "missing":
+            return field ? `delete key ${field}` : "delete field key";
+        case "null":
+            return field ? `set ${field}=None` : "set value=None";
+        case "max":
+            return field && bound !== undefined
+                ? `set ${field}="x"*${bound}`
+                : undefined;
+        case "max+1":
+            return field && bound !== undefined
+                ? `set ${field}="x"*${bound + 1}`
+                : undefined;
+        case "min":
+            return field && bound !== undefined
+                ? `set ${field}="x"*${bound}`
+                : undefined;
+        case "min-1":
+            return field && bound !== undefined
+                ? `set ${field}="x"*${Math.max(0, bound - 1)}`
+                : undefined;
+        case "pattern-invalid":
+            return field && example
+                ? `set ${field}=${JSON.stringify(example)}`
+                : undefined;
+        case "enum-invalid":
+        case "wrong-type":
+            return field && example
+                ? `set ${field}=${JSON.stringify(example)}`
+                : undefined;
+        default:
+            if (intent.startsWith("custom-literal:")) {
+                const expected = intent.slice("custom-literal:".length);
+                if (isWhitespaceSemanticLiteral(expected)) {
+                    return field ? `set ${field}="   "` : 'set value="   "';
+                }
+                if (isWhitespacePaddedSemanticLiteral(expected)) {
+                    return field
+                        ? `set ${field}="  ${field}-value  "`
+                        : 'set value="  value  "';
+                }
+                return field
+                    ? `set ${field}=${JSON.stringify(expected)}`
+                    : undefined;
+            }
+            return undefined;
+    }
+}
+function scenarioFunctionRegion(source, tpId) {
+    const idIndex = source.indexOf(`id="${tpId}"`) >= 0
+        ? source.indexOf(`id="${tpId}"`)
+        : source.indexOf(`id='${tpId}'`);
+    if (idIndex < 0)
+        return "";
+    const functionStart = source.indexOf("def test_", idIndex);
+    if (functionStart < 0)
+        return "";
+    const nextDecorator = source.indexOf("\n@pytest", functionStart + 1);
+    const nextFunction = source.indexOf("\ndef test_", functionStart + 1);
+    const candidates = [nextDecorator, nextFunction].filter((index) => index > functionStart);
+    const end = candidates.length > 0 ? Math.min(...candidates) : source.length;
+    return source.slice(functionStart, end);
+}
+function hasCreateDerivedJourney(source, tpId) {
+    const region = scenarioFunctionRegion(source, tpId);
+    return /\b_create[A-Za-z0-9_]*\s*\(/.test(region);
+}
+function hasCreateDeleteDerivedJourney(source, tpId) {
+    const region = scenarioFunctionRegion(source, tpId);
+    return /\b_create_deleted_id\s*\(/.test(region) ||
+        (/\b_create[A-Za-z0-9_]*\s*\(/.test(region) &&
+            (/\b_delete[A-Za-z0-9_]*\s*\(/.test(region) || /\.delete\s*\(/.test(region) || /\.request\s*\(\s*["']DELETE["']/i.test(region)));
+}
+export async function assessBackendScenarioParamConsistency(input) {
+    const cases = await listMarkdownCases(input.workspaceRoot, input.layout);
+    const entries = [];
+    const assetPaths = new Set();
+    for (const testCase of cases) {
+        if (!testCase.scriptPath)
+            continue;
+        assetPaths.add(testCase.scriptPath);
+        const absolute = path.join(input.workspaceRoot, testCase.scriptPath);
+        const source = (await exists(absolute))
+            ? await readFile(absolute, "utf8")
+            : "";
+        for (const tpId of testCase.variantTestPoints) {
+            const inferred = inferScenarioParamIntent({
+                tpId,
+                caseBody: testCase.body,
+            });
+            const fallbackSourced = inferred.intentSource === "tp-fallback";
+            const constants = source ? collectPythonStringConstants(source) : undefined;
+            const block = source ? extractPytestParamBlock(source, tpId) : undefined;
+            const parameterNames = source ? extractPytestParamParameterNames(source, tpId) : [];
+            const observed = observeParamFeatures(block, inferred.field, constants, parameterNames);
+            // Request-level / health checks often have no pytest.param payload row,
+            // or only a TP-id label positional (no field value).
+            const requestLevelNoParam = Boolean(source) &&
+                (inferred.intent === "nominal" || inferred.intent === "unknown") &&
+                ((!block && observed.text === "param-block-missing") ||
+                    (Boolean(block) &&
+                        !inferred.field &&
+                        (observed.kind === "unknown" ||
+                            observed.kind === "missing-key" ||
+                            (observed.kind === "string" &&
+                                Boolean(observed.literal) &&
+                                /^TP-[A-Z0-9-]+$/i.test(observed.literal ?? "")))));
+            const derivedJourneyMatch = Boolean(source) &&
+                inferred.field === "id" &&
+                ((/^custom-literal:(?:create-delete-derived(?:-id)?|deleted-existing-derived)$/i.test(inferred.intent) &&
+                    hasCreateDeleteDerivedJourney(source, tpId)) ||
+                    (/^custom-literal:(?:create-derived(?:-active-id|-id)?|active-existing-derived)$/i.test(inferred.intent) &&
+                        hasCreateDerivedJourney(source, tpId)));
+            const status = !source
+                ? "UNDETERMINED"
+                : derivedJourneyMatch
+                    ? "MATCH"
+                    : requestLevelNoParam
+                        ? "MATCH"
+                        : fallbackSourced
+                            ? "UNDETERMINED"
+                            : compareIntent(inferred.intent, observed, inferred.bound, inferred.example, inferred.field);
+            const repairability = repairabilityFor(status, inferred.intent, observed, inferred.example);
+            entries.push({
+                caseId: testCase.caseId,
+                tpId,
+                field: inferred.field,
+                intent: inferred.intent,
+                observed: observed.text,
+                status,
+                repairability,
+                suggestedFix: fallbackSourced
+                    ? undefined
+                    : suggestedFixFor(inferred.intent, inferred.field, inferred.bound, inferred.example),
+                scriptPath: testCase.scriptPath,
+                bound: inferred.bound,
+                example: inferred.example,
+            });
+        }
+    }
+    const assetHashes = [];
+    for (const rel of [...assetPaths].sort()) {
+        const absolute = path.join(input.workspaceRoot, rel);
+        if (!(await exists(absolute)))
+            continue;
+        assetHashes.push({
+            path: rel,
+            sha256: sha256(await readFile(absolute)),
+        });
+    }
+    const repairableCount = entries.filter((entry) => entry.repairability === "repairable" && entry.status === "MISMATCH").length;
+    const matchCount = entries.filter((entry) => entry.status === "MATCH").length;
+    const mismatchCount = entries.filter((entry) => entry.status === "MISMATCH").length;
+    const undeterminedCount = entries.filter((entry) => entry.status === "UNDETERMINED").length;
+    const overallStatus = mismatchCount > 0
+        ? "FAIL"
+        : matchCount === 0 && undeterminedCount > 0
+            ? "UNAVAILABLE"
+            : undeterminedCount > 0
+                ? "PARTIAL"
+                : "PASS";
+    const facts = {
+        schemaId: BACKEND_TEST_SCENARIO_PARAM_FACTS_SCHEMA_ID,
+        phase: input.phase,
+        overallStatus,
+        repairEligible: input.phase === "initial" && repairableCount > 0,
+        repairAttempt: input.repairAttempt ?? (input.phase === "final" ? 1 : 0),
+        strictScenarioParamGate: input.strictScenarioParamGate === true,
+        entries,
+        assetHashes,
+        summary: {
+            matchCount,
+            mismatchCount,
+            undeterminedCount,
+            repairableCount,
+            blockedCount: entries.filter((entry) => entry.repairability === "blocked")
+                .length,
+        },
+    };
+    const markdown = [
+        "# Backend Test Scenario-Param Consistency",
+        "",
+        `## Status`,
+        "",
+        facts.overallStatus,
+        "",
+        `## Summary`,
+        "",
+        `- Phase: ${facts.phase}`,
+        `- Repair eligible: ${facts.repairEligible}`,
+        `- Repair attempt: ${facts.repairAttempt}`,
+        `- MATCH: ${facts.summary.matchCount}`,
+        `- MISMATCH: ${facts.summary.mismatchCount}`,
+        `- UNDETERMINED: ${facts.summary.undeterminedCount}`,
+        `- Repairable mismatches: ${facts.summary.repairableCount}`,
+        `- Blocked: ${facts.summary.blockedCount}`,
+        "",
+        "## Entries",
+        "",
+        "| Case | TP | Field | Intent | Observed | Status | Repairability | Suggested fix |",
+        "|---|---|---|---|---|---|---|---|",
+        ...facts.entries.map((entry) => `| ${entry.caseId} | ${entry.tpId} | ${entry.field ?? "—"} | ${entry.intent} | ${entry.observed.replaceAll("|", "\\|")} | ${entry.status} | ${entry.repairability} | ${entry.suggestedFix ?? "—"} |`),
+        "",
+    ].join("\n");
+    return { facts, markdown };
+}
+export async function writeBackendScenarioParamArtifacts(input) {
+    const contractsDir = path.join(input.runDir, "contracts");
+    const reportsDir = path.join(input.runDir, "reports");
+    await mkdir(contractsDir, { recursive: true });
+    await mkdir(reportsDir, { recursive: true });
+    const stem = input.facts.phase === "final"
+        ? "backend-test-scenario-param-consistency-final"
+        : "backend-test-scenario-param-consistency";
+    const factsPath = path.join(contractsDir, `${stem}.json`);
+    const reportPath = path.join(reportsDir, `${stem}.md`);
+    const parsed = factsSchema.parse(input.facts);
+    await writeFile(factsPath, JSON.stringify(parsed, null, 2), "utf8");
+    await writeFile(reportPath, input.markdown, "utf8");
+    // Keep a stable non-suffixed alias for final as well for consumers.
+    if (input.facts.phase === "final") {
+        await writeFile(path.join(contractsDir, "backend-test-scenario-param-consistency-facts.json"), JSON.stringify(parsed, null, 2), "utf8");
+        await writeFile(path.join(reportsDir, "backend-test-scenario-param-consistency.md"), input.markdown, "utf8");
+    }
+    else {
+        await writeFile(path.join(contractsDir, "backend-test-scenario-param-consistency-facts.json"), JSON.stringify(parsed, null, 2), "utf8");
+    }
+    return { factsPath, reportPath };
+}
+export async function readBackendScenarioParamFacts(filePath) {
+    const raw = JSON.parse(await readFile(filePath, "utf8"));
+    return factsSchema.parse(raw);
+}
+function replaceFieldInDictLiteral(dictLiteral, field, mode, valueLiteral) {
+    const fieldPattern = new RegExp(`([\\t ]*)(["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*)([^,}\\n]+)`);
+    if (mode === "delete") {
+        if (!fieldPattern.test(dictLiteral))
+            return dictLiteral;
+        return dictLiteral
+            .replace(new RegExp(`,\\s*["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*[^,}\\n]+`), "")
+            .replace(new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*[^,}\\n]+\\s*,?`), "");
+    }
+    if (fieldPattern.test(dictLiteral)) {
+        return dictLiteral.replace(fieldPattern, `$1$2${valueLiteral}`);
+    }
+    // Insert before closing brace. Normalize an existing trailing comma first so
+    // adding a missing field can never produce `,,` and corrupt Python syntax.
+    const withoutClosingBrace = dictLiteral.replace(/\s*\}$/, "");
+    const trimmed = withoutClosingBrace.replace(/,\s*$/, "").trimEnd();
+    const hasEntries = trimmed.trim() !== "{";
+    return `${trimmed}${hasEntries ? ", " : ""}${JSON.stringify(field)}: ${valueLiteral}}`;
+}
+export function deterministicRewriteScenarioParam(input) {
+    const { entry } = input;
+    if (entry.repairability !== "repairable" || !entry.field) {
+        return { ok: false, source: input.source, detail: "not repairable or missing field" };
+    }
+    const block = extractPytestParamBlock(input.source, entry.tpId);
+    if (!block) {
+        return { ok: false, source: input.source, detail: "param block not found" };
+    }
+    // Prefer the first object literal in the param block (payload dict).
+    const dictMatch = /\{[^{}]*\}/.exec(block);
+    if (!dictMatch) {
+        return { ok: false, source: input.source, detail: "no dict payload in param" };
+    }
+    const originalDict = dictMatch[0];
+    const field = entry.field;
+    const bound = entry.bound;
+    let valueLiteral;
+    let mode = "set";
+    switch (entry.intent) {
+        case "empty":
+            valueLiteral = '""';
+            break;
+        case "missing":
+            mode = "delete";
+            break;
+        case "null":
+            valueLiteral = "None";
+            break;
+        case "max":
+        case "min":
+            if (bound === undefined) {
+                return { ok: false, source: input.source, detail: `missing bound for ${entry.intent}` };
+            }
+            valueLiteral = `"x" * ${bound}`;
+            break;
+        case "max+1":
+            if (bound === undefined) {
+                return { ok: false, source: input.source, detail: "missing bound for max+1" };
+            }
+            valueLiteral = `"x" * ${bound + 1}`;
+            break;
+        case "min-1":
+            if (bound === undefined) {
+                return { ok: false, source: input.source, detail: "missing bound for min-1" };
+            }
+            valueLiteral = `"x" * ${Math.max(0, bound - 1)}`;
+            break;
+        case "pattern-invalid":
+            if (entry.example === undefined) {
+                return {
+                    ok: false,
+                    source: input.source,
+                    detail: "missing example for pattern-invalid",
+                };
+            }
+            valueLiteral = JSON.stringify(entry.example);
+            break;
+        default:
+            if (entry.intent.startsWith("custom-literal:")) {
+                valueLiteral = JSON.stringify(entry.intent.slice("custom-literal:".length));
+                break;
+            }
+            return {
+                ok: false,
+                source: input.source,
+                detail: `intent ${entry.intent} not in deterministic closed set`,
+            };
+    }
+    const nextDict = replaceFieldInDictLiteral(originalDict, field, mode, valueLiteral);
+    if (nextDict === originalDict) {
+        return { ok: false, source: input.source, detail: "rewrite produced no change" };
+    }
+    const nextBlock = block.replace(originalDict, nextDict);
+    const nextSource = input.source.replace(block, nextBlock);
+    if (nextSource.includes("pytest.skip") || nextSource.includes("pytest.xfail")) {
+        return { ok: false, source: input.source, detail: "rewrite introduced skip/xfail" };
+    }
+    return { ok: true, source: nextSource, detail: "rewritten" };
+}
+function validatePythonSyntaxWithoutExecution(source) {
+    // POSIX images usually expose `python3`; Windows often has a real `python`
+    // plus a Microsoft Store `python3` stub that exits nonzero without parsing.
+    // A stub/missing interpreter must not silently roll back an otherwise-valid
+    // deterministic rewrite.
+    const candidates = process.platform === "win32" ? ["python", "python3"] : ["python3", "python"];
+    let lastError;
+    for (const interpreter of candidates) {
+        const result = spawnSync(interpreter, ["-c", "import ast,sys; ast.parse(sys.stdin.read())"], {
+            input: source,
+            encoding: "utf8",
+            env: {
+                ...process.env,
+                PYTHONDONTWRITEBYTECODE: "1",
+                PYTHONUTF8: "1",
+            },
+            timeout: 15_000,
+        });
+        if (result.error) {
+            lastError = result.error.message;
+            continue;
+        }
+        if (result.status !== 0) {
+            const detail = String(result.stderr || result.stdout || "invalid Python syntax")
+                .trim()
+                .replace(/\s+/g, " ")
+                .slice(0, 500);
+            const looksLikeStub = !detail ||
+                /microsoft store|windowsapps|python was not found|not recognized/i.test(detail);
+            if (looksLikeStub) {
+                lastError = detail || `exit ${result.status}`;
+                continue;
+            }
+            return { ok: false, detail: `python syntax validation failed: ${detail}` };
+        }
+        return { ok: true, detail: "python ast.parse PASS" };
+    }
+    return {
+        ok: false,
+        detail: `python syntax validation unavailable: ${lastError ?? "python/python3 not found"}`,
+    };
+}
+export async function applyDeterministicScenarioParamRepairs(input) {
+    const repairable = input.facts.entries.filter((entry) => entry.status === "MISMATCH" && entry.repairability === "repairable");
+    const byScript = new Map();
+    for (const entry of repairable) {
+        if (!entry.scriptPath)
+            continue;
+        const list = byScript.get(entry.scriptPath) ?? [];
+        list.push(entry);
+        byScript.set(entry.scriptPath, list);
+    }
+    const beforeHashes = [...input.facts.assetHashes];
+    const changedFiles = [];
+    const repaired = [];
+    const skipped = [];
+    const auditEntries = [];
+    for (const [scriptPath, entries] of byScript) {
+        const absolute = path.join(input.workspaceRoot, scriptPath);
+        if (!(await exists(absolute))) {
+            for (const entry of entries) {
+                skipped.push({ tpId: entry.tpId, detail: "script missing" });
+                auditEntries.push({
+                    tpId: entry.tpId,
+                    result: "skipped",
+                    detail: "script missing",
+                });
+            }
+            continue;
+        }
+        let source = await readFile(absolute, "utf8");
+        const staged = [];
+        for (const entry of entries) {
+            const result = deterministicRewriteScenarioParam({ source, entry });
+            if (!result.ok) {
+                skipped.push({ tpId: entry.tpId, detail: result.detail });
+                auditEntries.push({
+                    tpId: entry.tpId,
+                    result: "skipped-to-pi",
+                    detail: result.detail,
+                });
+                continue;
+            }
+            source = result.source;
+            staged.push({ entry, detail: result.detail });
+        }
+        if (staged.length > 0) {
+            const syntax = validatePythonSyntaxWithoutExecution(source);
+            if (!syntax.ok) {
+                for (const item of staged) {
+                    skipped.push({ tpId: item.entry.tpId, detail: syntax.detail });
+                    auditEntries.push({
+                        tpId: item.entry.tpId,
+                        result: "rolled-back-invalid-python",
+                        detail: syntax.detail,
+                    });
+                }
+                continue;
+            }
+            await writeFile(absolute, source, "utf8");
+            changedFiles.push(scriptPath);
+            for (const item of staged) {
+                repaired.push(item.entry.tpId);
+                auditEntries.push({
+                    tpId: item.entry.tpId,
+                    result: "rewritten",
+                    detail: `${item.detail}; ${syntax.detail}`,
+                });
+            }
+        }
+    }
+    const afterHashes = [];
+    for (const item of beforeHashes) {
+        const absolute = path.join(input.workspaceRoot, item.path);
+        if (!(await exists(absolute)))
+            continue;
+        afterHashes.push({
+            path: item.path,
+            sha256: sha256(await readFile(absolute)),
+        });
+    }
+    return {
+        changedFiles,
+        repaired,
+        skipped,
+        audit: { beforeHashes, afterHashes, entries: auditEntries },
+    };
+}
+export async function writeScenarioParamRepairAudit(input) {
+    const contractsDir = path.join(input.runDir, "contracts");
+    await mkdir(contractsDir, { recursive: true });
+    const filePath = path.join(contractsDir, "backend-test-scenario-param-repair-audit.json");
+    await writeFile(filePath, JSON.stringify({
+        schemaId: "backend-test-scenario-param-repair-audit-v1",
+        changedFiles: input.changedFiles,
+        ...input.audit,
+    }, null, 2), "utf8");
+    return filePath;
+}
+export function renderBackendTestFailureAnalysis(input) {
+    const overviewNarrative = input.failed + input.errors === 0
+        ? "本轮无失败用例。报告仍保留场景-参数一致性与执行摘要，供审计。"
+        : `本轮共 ${input.failed} 个失败用例、${input.errors} 个错误用例。分类优先参考场景-参数一致性 final facts，再结合断言与环境证据。`;
+    return [
+        "# 测试失败用例分析报告",
+        "",
+        `> 报告生成时间：${input.generatedAt}`,
+        `> 测试报告来源：${input.htmlReportPath}`,
+        `> 测试总计：${input.total} 个用例（${input.passed} Passed, ${input.failed} Failed, ${input.errors} Error）`,
+        `> 测试耗时：${input.durationLabel}`,
+        `> 测试环境：${input.environmentSummary.split("\n")[0] ?? "unavailable"}`,
+        `> 接口：${input.primaryOperation ?? "—"}`,
+        `> 环境基址：${input.baseUrl ?? "—"}`,
+        `> 场景-参数一致性：${input.scenarioParamFinalStatus}（repairAttempt=${input.repairAttempt}）`,
+        "",
+        "---",
+        "",
+        "## 一、失败用例概览",
+        "",
+        overviewNarrative,
+        "",
+        "| # | 测试用例 | 场景描述 | 期望码 | 实际码 | 失败分类 |",
+        "|---|---------|---------|--------|--------|---------|",
+        ...(input.failures.length
+            ? input.failures.map((item, index) => `| ${index + 1} | ${item.caseId} / ${item.name} | ${item.scenario.replaceAll("|", "\\|")} | ${item.expectedCode ?? "—"} | ${item.actualCode ?? "—"} | ${item.classification} |`)
+            : ["| — | — | — | — | — | 无失败 |"]),
+        "",
+        "---",
+        "",
+        "## 二、逐个失败用例详细分析",
+        "",
+        ...(input.failures.length
+            ? input.failures.flatMap((item, index) => [
+                `### 失败用例 ${index + 1}：${item.name}`,
+                "| 项目 | 内容 |",
+                "|------|------|",
+                `| 用例 ID | ${item.caseId} |`,
+                `| 接口 URL | ${item.scriptPath ?? "—"} |`,
+                `| 场景描述 | ${item.scenario.replaceAll("|", "\\|")} |`,
+                `| 需求依据 | ${item.requirementRef ?? "—"} |`,
+                `| 期望码 / 实际码 | ${item.expectedCode ?? "—"} / ${item.actualCode ?? "—"} |`,
+                `| 耗时 | ${item.durationLabel ?? "—"} |`,
+                `| 场景-参数评估 | ${item.scenarioParamStatus ?? "UNAVAILABLE"} |`,
+                "",
+                `**传入参数：** ${item.requestSummary ?? "见 pytest-html 执行日志"}`,
+                "",
+                `**失败原因：** ${item.message.replaceAll("|", "\\|")}`,
+                "",
+                `**缺陷定位：** ${item.classification}`,
+                "",
+            ])
+            : ["本轮无失败用例详析。", ""]),
+    ].join("\n");
+}
+export function classifyBackendTestFailureWithScenarioParam(input) {
+    if (input.scenarioParamStatus === "MISMATCH") {
+        return "测试脚本参数与场景不匹配（或自修后仍不一致）";
+    }
+    const evidence = [input.message, input.details].filter(Boolean).join("\n");
+    if (/ImportError|ModuleNotFoundError|fixture|CONNECTION|ECONNREFUSED/i.test(evidence)) {
+        return "环境或测试基础设施问题";
+    }
+    if (/assert\s+\d{3}\s*==\s*\d{3}|状态码/i.test(evidence)) {
+        return "后端行为与契约不一致";
+    }
+    return "证据不足-待确认";
+}