@tea-agent/loop-agent 0.33.6 → 0.33.7-beta.1

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

@@ -98,10 +98,16 @@ async function listMarkdownCases(workspaceRoot) {
             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 = variantFromLabel.length > 0
-                ? variantFromLabel
-                : allPoints.filter((tp) => /(EMPTY|MISSING|NULL|MIN|MAX|INVALID|WRONG|ENUM|PATTERN|NOMINAL|BOUNDARY)/i.test(tp));
+            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 scriptMatch = body.match(/`?(testcase\/[A-Za-z0-9_./-]*test_[A-Za-z0-9_.-]*\.py)`?/i);
             cases.push({
                 caseId,
@@ -115,23 +121,153 @@ async function listMarkdownCases(workspaceRoot) {
     }
     return cases;
 }
+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*(.+?)(?:\s*[|;]\s*bound\s*=\s*(\d+))?(?:\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: precise[5] ? Number(precise[5]) : undefined,
+            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*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(line.trim());
+    if (legacy) {
+        return {
+            rawIntent: (legacy[1] ?? "unknown").trim(),
+            field: legacy[2],
+            bound: legacy[3] ? Number(legacy[3]) : undefined,
+            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 preciseLine = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;,，]\s*operation\s*=\s*([^|;,，\n]+)\s*[|;,，]\s*target\s*=\s*([A-Za-z0-9_.-]+)\s*[|;,，]\s*intent\s*=\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(caseBody);
-    const legacyLine = /场景意图\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);
-    const fallbackLine = new RegExp(`${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,160}?intent\\s*[=:]\\s*([a-z0-9+._:-]+)`, "i").exec(caseBody);
-    const machineLine = preciseLine ?? legacyLine ?? fallbackLine;
-    if (machineLine) {
-        const rawIntent = (preciseLine ? preciseLine[4] : machineLine[1] ?? "unknown").toLowerCase();
-        const target = preciseLine?.[3];
-        const field = target && target !== "request" ? target.split(".").at(-1) : legacyLine?.[2];
-        const boundRaw = preciseLine?.[5] ?? legacyLine?.[3];
-        const example = (preciseLine?.[6] ?? legacyLine?.[4])?.trim();
-        const bound = boundRaw ? Number(boundRaw) : undefined;
-        const normalizedIntent = rawIntent === "nominal-operation" ? "nominal" : rawIntent;
-        if (normalizedIntent.startsWith("custom-literal:")) {
+    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();
+        const normalizedIntent = lower === "nominal-operation" ? "nominal" : lower;
+        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 intent = resolveCustomLiteralIntent(rawIntent, field);
             return {
-                intent: normalizedIntent,
+                intent,
                 field,
                 bound,
                 example,
@@ -169,13 +305,29 @@ export function inferScenarioParamIntent(input) {
         "VARIANT",
         "WHITESPACE",
         "UNKNOWN",
+        "HEALTH",
+        "UP",
+        "OK",
+        "GET",
+        "API",
+        "STATUS",
+        "CODE",
+        "HTTP",
+        "RESPONSE",
+        "REQUEST",
     ].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 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();
@@ -214,6 +366,147 @@ export function inferScenarioParamIntent(input) {
     }
     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|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) or NBSP variants.
+    return value
+        .replace(/␠/g, " ")
+        .replace(/ /g, " ")
+        .replace(/ /g, " ")
+        .replace(/ /g, " ");
+}
+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 observeLiteralToken(raw, field) {
+    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);
+    }
+    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("["))
+        return { kind: "list", text: trimmed };
+    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);
+        }
+        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" };
+        }
+        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)];
@@ -248,88 +541,160 @@ export function observeParamFeatures(block, field) {
     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.
+    // 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);
-    if (dictMatch && !field) {
-        return { kind: "dict", text: (dictMatch[0] ?? dictMatch[1] ?? "{}").replace(/\s+/g, " ").slice(0, 160) };
+    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 (dictMatch && field) {
-        const dict = dictMatch[0] ?? dictMatch[1] ?? "";
-        const fieldPattern = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:`);
-        if (!fieldPattern.test(dict)) {
+    if (dictLooksLikePayload && field) {
+        if (!dictHasField) {
             return { kind: "missing-key", text: `missing:${field}` };
         }
-        const valueMatch = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*([^,}\\n]+)`).exec(dict);
+        const valueMatch = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*([^,}\n]+)`).exec(dictText);
         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 (observeLiteralToken(raw, field) ?? {
+            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",
+        };
+    }
+    // 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]*?\'\'\'|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[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;
         }
-        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 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);
+            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) ?? {
+                kind: "unknown",
+                text: raw,
+            });
         }
-        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,
-            };
+        // 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: raw };
     }
     return { kind: "unknown", text: compact.slice(0, 160) };
 }
-function compareIntent(intent, observed, bound, example) {
+function observedLengthValue(observed) {
+    if (observed.kind === "number" && observed.literal !== undefined) {
+        const n = Number(observed.literal);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    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";
-    if (observed.kind === "call" || observed.kind === "name") {
+    // 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 === "string" && observed.length === 0)
+                (observed.kind === "string" &&
+                    (observed.length === 0 ||
+                        (typeof observed.literal === "string" &&
+                            /^\s+$/.test(observed.literal))))
                 ? "MATCH"
                 : observed.kind === "unknown"
                     ? "UNDETERMINED"
@@ -347,45 +712,49 @@ function compareIntent(intent, observed, bound, example) {
                     ? "UNDETERMINED"
                     : "MISMATCH";
         case "max":
-            return bound !== undefined &&
-                observed.kind === "string" &&
-                observed.length === bound
-                ? "MATCH"
-                : bound === undefined
-                    ? "UNDETERMINED"
-                    : observed.kind === "string"
-                        ? "MISMATCH"
-                        : "UNDETERMINED";
+            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":
-            return bound !== undefined &&
-                observed.kind === "string" &&
-                observed.length === bound + 1
-                ? "MATCH"
-                : bound === undefined
-                    ? "UNDETERMINED"
-                    : observed.kind === "string"
-                        ? "MISMATCH"
-                        : "UNDETERMINED";
+            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":
-            return bound !== undefined &&
-                observed.kind === "string" &&
-                observed.length === bound
-                ? "MATCH"
-                : bound === undefined
-                    ? "UNDETERMINED"
-                    : observed.kind === "string"
-                        ? "MISMATCH"
-                        : "UNDETERMINED";
+            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":
-            return bound !== undefined &&
-                observed.kind === "string" &&
-                observed.length === Math.max(0, bound - 1)
-                ? "MATCH"
-                : bound === undefined
-                    ? "UNDETERMINED"
-                    : observed.kind === "string"
-                        ? "MISMATCH"
-                        : "UNDETERMINED";
+            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";
@@ -401,10 +770,21 @@ function compareIntent(intent, observed, bound, example) {
                     ? "MISMATCH"
                     : "UNDETERMINED";
         case "enum-invalid":
-            return observed.kind === "string" || observed.kind === "number"
+            // 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"
-                : "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" ||
@@ -416,8 +796,36 @@ function compareIntent(intent, observed, bound, example) {
                     : "UNDETERMINED";
         default:
             if (intent.startsWith("custom-literal:")) {
-                const expected = intent.slice("custom-literal:".length);
-                return observed.literal === expected
+                const expectedRaw = intent.slice("custom-literal:".length);
+                const expected = normalizeCustomLiteralExpected(expectedRaw);
+                const literal = normalizeScenarioLiteralText(observed.literal ?? "");
+                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"
@@ -483,8 +891,17 @@ function suggestedFixFor(intent, field, bound, 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(intent.slice("custom-literal:".length))}`
+                    ? `set ${field}=${JSON.stringify(expected)}`
                     : undefined;
             }
             return undefined;
@@ -510,9 +927,20 @@ export async function assessBackendScenarioParamConsistency(input) {
             const fallbackSourced = inferred.intentSource === "tp-fallback";
             const block = source ? extractPytestParamBlock(source, tpId) : undefined;
             const observed = observeParamFeatures(block, inferred.field);
-            const status = !source || fallbackSourced
+            // Request-level / health checks often have no pytest.param payload row.
+            // Treat missing param blocks for nominal/unknown intents as MATCH so they
+            // do not pollute eligibility with false UNDETERMINED residuals.
+            const requestLevelNoParam = Boolean(source) &&
+                !block &&
+                observed.text === "param-block-missing" &&
+                (inferred.intent === "nominal" || inferred.intent === "unknown");
+            const status = !source
                 ? "UNDETERMINED"
-                : compareIntent(inferred.intent, observed, inferred.bound, inferred.example);
+                : 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,