@tea-agent/loop-agent 0.28.13 → 0.29.0

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

@@ -0,0 +1,846 @@
+import { createHash } from "node:crypto";
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { expectedBackendTestPytestScriptForMarkdownModule, } from "./backend-test-markdown-workflow.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"]),
+    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) {
+    const root = path.join(workspaceRoot, "testcase", "md");
+    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("testcase/md", 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 variantFromLabel = orderedUnique((variantLabel.match(/\bTP-[A-Z0-9-]+\b/g) ?? []).filter((item) => item.toUpperCase() !== "NONE"));
+            const variantTestPoints = variantFromLabel.length > 0
+                ? variantFromLabel
+                : allPoints.filter((tp) => /(EMPTY|MISSING|NULL|MIN|MAX|INVALID|WRONG|ENUM|PATTERN|NOMINAL|BOUNDARY)/i.test(tp));
+            const scriptMatch = body.match(/`?(testcase\/[A-Za-z0-9_./-]*test_[A-Za-z0-9_.-]*\.py)`?/i);
+            cases.push({
+                caseId,
+                body,
+                markdownPath: rel,
+                variantTestPoints: variantTestPoints.length > 0 ? variantTestPoints : allPoints.slice(0, 1),
+                scriptPath: scriptMatch?.[1] ??
+                    expectedBackendTestPytestScriptForMarkdownModule(name),
+            });
+        }
+    }
+    return cases;
+}
+export function inferScenarioParamIntent(input) {
+    const { tpId, caseBody } = input;
+    const machineLine = /场景意图\s*[:：]\s*([a-z0-9+._-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(caseBody) ??
+        new RegExp(`${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,120}?intent\\s*[=:]\\s*([a-z0-9+._-]+)`, "i").exec(caseBody);
+    if (machineLine) {
+        const rawIntent = (machineLine[1] ?? "unknown").toLowerCase();
+        const field = machineLine[2];
+        const bound = machineLine[3] ? Number(machineLine[3]) : undefined;
+        const example = machineLine[4]?.trim();
+        if (rawIntent.startsWith("custom-literal:")) {
+            return {
+                intent: rawIntent,
+                field,
+                bound,
+                example,
+            };
+        }
+        return {
+            intent: (CLOSED_SET.has(rawIntent) ? rawIntent : "unknown"),
+            field,
+            bound,
+            example,
+        };
+    }
+    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",
+    ].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 boundMatch = /(?: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 };
+    }
+    if (/MISSING|缺省|缺失|省略/.test(upper) || /缺少字段|缺失字段|missing field/i.test(caseBody)) {
+        return { intent: "missing", field, bound, example };
+    }
+    if (/\bNULL\b|空值/.test(upper) || /\bnull\b/i.test(caseBody)) {
+        return { intent: "null", field, bound, example };
+    }
+    if (/MAX[-_]?PLUS[-_]?1|MAX\+1|超长|越界/.test(upper)) {
+        return { intent: "max+1", field, bound, example };
+    }
+    if (/\bMAX\b|最大/.test(upper))
+        return { intent: "max", field, bound, example };
+    if (/MIN[-_]?1|最小减|min-1/i.test(upper)) {
+        return { intent: "min-1", field, bound, example };
+    }
+    if (/\bMIN\b|最小/.test(upper))
+        return { intent: "min", field, bound, example };
+    if (/WRONG[-_]?TYPE|类型错误/.test(upper)) {
+        return { intent: "wrong-type", field, bound, example };
+    }
+    if (/ENUM.*INVALID|INVALID.*ENUM|非法枚举/.test(upper)) {
+        return { intent: "enum-invalid", field, bound, example };
+    }
+    if (/PATTERN|FORMAT|UPPERCASE|大写|非法格式/.test(upper)) {
+        return { intent: "pattern-invalid", field, bound, example };
+    }
+    if (/NOMINAL|正常|合法|主路径|SUCCESS/.test(upper)) {
+        return { intent: "nominal", field, bound, example };
+    }
+    return { intent: "unknown", field, bound, example };
+}
+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;
+}
+export function observeParamFeatures(block, field) {
+    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.
+    const dictMatch = /\{\s*([\s\S]*?)\s*\}/.exec(block) ??
+        /(?:payload|body|data|json)\s*=\s*(\{[\s\S]*?\})/.exec(block);
+    if (dictMatch && field) {
+        const dict = dictMatch[0] ?? dictMatch[1] ?? "";
+        const fieldPattern = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:`);
+        if (!fieldPattern.test(dict)) {
+            return { kind: "missing-key", text: `missing:${field}` };
+        }
+        const valueMatch = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*([^,}\\n]+)`).exec(dict);
+        const raw = valueMatch?.[1]?.trim() ?? "";
+        if (raw === "None" || raw === "null") {
+            return { kind: "none", text: "None", literal: "None" };
+        }
+        if (raw === '""' || raw === "''") {
+            return { kind: "empty-string", text: '""', length: 0, literal: "" };
+        }
+        const str = /^["']([\s\S]*)["']$/.exec(raw);
+        if (str) {
+            const value = str[1] ?? "";
+            return {
+                kind: "string",
+                text: JSON.stringify(value),
+                length: value.length,
+                hasUppercase: /[A-Z]/.test(value),
+                literal: value,
+            };
+        }
+        if (/^\d+(?:\.\d+)?$/.test(raw)) {
+            return { kind: "number", text: raw, literal: raw };
+        }
+        if (raw === "True" || raw === "False") {
+            return { kind: "boolean", text: raw, literal: raw };
+        }
+        if (raw.startsWith("["))
+            return { kind: "list", text: raw };
+        if (raw.startsWith("{"))
+            return { kind: "dict", text: raw };
+        if (/\(/.test(raw))
+            return { kind: "call", text: raw };
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(raw)) {
+            return { kind: "name", text: raw };
+        }
+        return { kind: "unknown", text: raw || compact.slice(0, 120) };
+    }
+    // Positional first arg string/None.
+    const firstArg = /pytest\.param\s*\(\s*(None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')/.exec(block);
+    if (firstArg) {
+        const raw = firstArg[1];
+        if (raw === "None")
+            return { kind: "none", text: "None", literal: "None" };
+        if (raw === '""' || raw === "''") {
+            return { kind: "empty-string", text: '""', length: 0, literal: "" };
+        }
+        const str = /^["']([\s\S]*)["']$/.exec(raw) ?? /^("""|''')([\s\S]*)\1$/.exec(raw);
+        if (str) {
+            const value = (str[2] ?? str[1] ?? "").replace(/^["']|["']$/g, "");
+            return {
+                kind: "string",
+                text: JSON.stringify(value),
+                length: value.length,
+                hasUppercase: /[A-Z]/.test(value),
+                literal: value,
+            };
+        }
+        return { kind: "unknown", text: raw };
+    }
+    return { kind: "unknown", text: compact.slice(0, 160) };
+}
+function compareIntent(intent, observed, bound) {
+    if (intent === "unknown")
+        return "UNDETERMINED";
+    if (observed.kind === "call" || observed.kind === "name") {
+        return "UNDETERMINED";
+    }
+    switch (intent) {
+        case "empty":
+            return observed.kind === "empty-string" ||
+                (observed.kind === "string" && observed.length === 0)
+                ? "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":
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === bound
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
+        case "max+1":
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === bound + 1
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
+        case "min":
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === bound
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
+        case "min-1":
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === Math.max(0, bound - 1)
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
+        case "pattern-invalid":
+            if (observed.kind === "string" && observed.hasUppercase)
+                return "MATCH";
+            if (observed.kind === "string")
+                return "MISMATCH";
+            return "UNDETERMINED";
+        case "wrong-type":
+            return observed.kind === "number" ||
+                observed.kind === "boolean" ||
+                observed.kind === "list" ||
+                observed.kind === "dict"
+                ? "MATCH"
+                : observed.kind === "string" || observed.kind === "empty-string"
+                    ? "MISMATCH"
+                    : "UNDETERMINED";
+        case "enum-invalid":
+            return observed.kind === "string" || observed.kind === "number"
+                ? "UNDETERMINED"
+                : "UNDETERMINED";
+        case "nominal":
+            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 expected = intent.slice("custom-literal:".length);
+                return observed.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 === "pattern-invalid" ||
+        intent === "enum-invalid" ||
+        intent === "wrong-type") &&
+        !example &&
+        !intent.startsWith("custom-literal:")) {
+        // pattern-invalid with uppercase heuristic is still repairable to a fixed anti-example.
+        if (intent === "pattern-invalid")
+            return "repairable";
+        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
+                ? `set ${field}=${JSON.stringify(example ?? "INVALID")}`
+                : undefined;
+        case "enum-invalid":
+        case "wrong-type":
+            return field && example
+                ? `set ${field}=${JSON.stringify(example)}`
+                : undefined;
+        default:
+            if (intent.startsWith("custom-literal:")) {
+                return field
+                    ? `set ${field}=${JSON.stringify(intent.slice("custom-literal:".length))}`
+                    : undefined;
+            }
+            return undefined;
+    }
+}
+export async function assessBackendScenarioParamConsistency(input) {
+    const cases = await listMarkdownCases(input.workspaceRoot);
+    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 block = source ? extractPytestParamBlock(source, tpId) : undefined;
+            const observed = observeParamFeatures(block, inferred.field);
+            const status = !source
+                ? "UNDETERMINED"
+                : compareIntent(inferred.intent, observed, inferred.bound);
+            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: 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 facts = {
+        schemaId: BACKEND_TEST_SCENARIO_PARAM_FACTS_SCHEMA_ID,
+        phase: input.phase,
+        repairEligible: input.phase === "initial" && repairableCount > 0,
+        repairAttempt: input.repairAttempt ?? (input.phase === "final" ? 1 : 0),
+        strictScenarioParamGate: input.strictScenarioParamGate === true,
+        entries,
+        assetHashes,
+        summary: {
+            matchCount: entries.filter((entry) => entry.status === "MATCH").length,
+            mismatchCount: entries.filter((entry) => entry.status === "MISMATCH")
+                .length,
+            undeterminedCount: entries.filter((entry) => entry.status === "UNDETERMINED").length,
+            repairableCount,
+            blockedCount: entries.filter((entry) => entry.repairability === "blocked")
+                .length,
+        },
+    };
+    const markdown = [
+        "# Backend Test Scenario-Param Consistency",
+        "",
+        `## Status`,
+        "",
+        facts.summary.mismatchCount > 0 ? "FAIL" : "PASS",
+        "",
+        `## 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.
+    const trimmed = dictLiteral.replace(/\s*\}$/, "");
+    const needsComma = /:\s*[^,}\s][^}]*$/.test(trimmed);
+    return `${trimmed}${needsComma ? ", " : ""}${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":
+            valueLiteral = JSON.stringify(entry.example ?? "INVALID");
+            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" };
+}
+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");
+        let fileChanged = false;
+        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;
+            fileChanged = true;
+            repaired.push(entry.tpId);
+            auditEntries.push({
+                tpId: entry.tpId,
+                result: "rewritten",
+                detail: result.detail,
+            });
+        }
+        if (fileChanged) {
+            await writeFile(absolute, source, "utf8");
+            changedFiles.push(scriptPath);
+        }
+    }
+    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 === 0
+        ? "本轮无失败用例。报告仍保留场景-参数一致性与执行摘要，供审计。"
+        : `本轮共 ${input.failed} 个失败/错误用例。分类优先参考场景-参数一致性 final facts，再结合断言与环境证据。`;
+    return [
+        "# 测试失败用例分析报告",
+        "",
+        `> 报告生成时间：${input.generatedAt}`,
+        `> 测试报告来源：${input.htmlReportPath}`,
+        `> 测试总计：${input.total} 个用例（${input.passed} Passed, ${input.failed} Failed）`,
+        `> 测试耗时：${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 "证据不足-待确认";
+}