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

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+### 改进
+
+- scenario-param 观测识别 `_OMIT`/omit sentinel 为合法 `missing`，跳过 `"2xx"`/`"400"` 期望码位置参数，解码 Python `\t`/`\n` 空白字面量，识别 `_TITLE_LEN1` 等长度 helper 名，支持 `custom-literal:whitespace-only|whitespace-padded` 语义标签，`enum-invalid` 接受具体非法字面量，并在 `min`/`LEN1` 意图下优先读取 TP 编码长度与 `minLength` 边界
+- scenario-param 兼容 `empty` 意图下的 omit/`missing-key`，规范化 `custom-literal` 外包引号与可见空白符，并把 `max+1`/`min`/`max` 的裸数字位置参数按长度 token 比较（含 oversized 数字本身）；`custom-literal:trim` 视为 padded whitespace 语义标签
+- backend-test writer 合同明确：`enum-invalid` 必须使用具体非法字面量且禁止 `_OMIT`/missing-key；`custom-literal:trim|ACTIVE|ARCHIVED` 必须使用真实 padded/enum 字面量，禁止 `filter-active` 类描述性伪值
+- scenario-param 识别 `_*_MAX_LENGTH` / `_*_OVER_LENGTH` 等长度 helper 名，明确 `custom-literal:trim` 不能是全空白，并把无 pytest.param 的 request-level/health nominal 记为 MATCH 以免污染 eligibility
+
+## [0.33.7-beta.1] - 2026-08-12
+
+### Fixed
+- scenario-param 识别 `_*_MAX_LENGTH` / `_*_OVER_LENGTH` 等长度 helper 名，明确 `custom-literal:trim` 不能是全空白，并把无 pytest.param 的 request-level/health nominal 记为 MATCH 以免污染 eligibility
+- backend-test writer 合同明确：`enum-invalid` 必须使用具体非法字面量且禁止 `_OMIT`/missing-key；`custom-literal:trim|ACTIVE|ARCHIVED` 必须使用真实 padded/enum 字面量；max/min/max+1 应用长度表达式/helper
+
+### Changed
+- 归档 R108–R110 live campaign 证据与 residual 收紧结果
+
 ## [0.33.7-beta.0] - 2026-08-11
 
 ### 重点更新

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

@@ -222,18 +222,48 @@ export function inferScenarioParamIntent(input) {
         const lower = rawIntent.toLowerCase();
         const normalizedIntent = lower === "nominal-operation" ? "nominal" : lower;
         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}`)
+        const haystack = `${caseBody}\n${dataSection}`;
+        const fieldEsc = field
+            ? field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
             : undefined;
-        const boundFromBody = 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 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
-            : boundFromBody
-                ? Number(boundFromBody[1])
-                : machine.bound;
+            : lengthIntent && boundFromTpNormalized !== undefined
+                ? boundFromTpNormalized
+                : boundFromBody
+                    ? Number(boundFromBody[1])
+                    : machine.bound;
         if (rawIntent.toLowerCase().startsWith("custom-literal:")) {
             const intent = resolveCustomLiteralIntent(rawIntent, field);
             return {
@@ -275,6 +305,16 @@ 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
@@ -326,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)];
@@ -380,55 +561,12 @@ export function observeParamFeatures(block, field) {
         if (!dictHasField) {
             return { kind: "missing-key", text: `missing:${field}` };
         }
-        const dict = dictText;
-        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 repeatedValue = /^(["'])([^"'\\])\1\s*\*\s*(\d{1,5})$/.exec(raw);
-        if (repeatedValue) {
-            const ch = repeatedValue[2] ?? "x";
-            const length = Number(repeatedValue[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,
-            };
-        }
-        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) };
+        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) ??
@@ -445,75 +583,113 @@ export function observeParamFeatures(block, field) {
             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 positionalLiterals = [];
-        const literalRe = /\s*(None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*(?:,|$)/g;
+        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 = literalRe.exec(afterOpen)) !== null) {
-            // Stop once keyword args begin (id=/marks=) after a comma segment without a pure literal.
+        while ((match = tokenRe.exec(afterOpen)) !== null) {
             const between = afterOpen.slice(0, match.index);
             if (/(?:^|,)\s*(?:id|marks)\s*=/.test(between + match[0]))
                 break;
-            positionalLiterals.push(match[1]);
-            if (positionalLiterals.length >= 4)
+            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 = positionalLiterals.filter((raw) => {
-            const str = /^["']([\s\S]*)["']$/.exec(raw) ?? /^("""|''')([\s\S]*)\1$/.exec(raw);
-            if (!str)
-                return true;
-            const value = (str[2] ?? str[1] ?? "").replace(/^["']|["']$/g, "");
-            // Drop pure TP label positionals that only echo the param id.
-            if (/^TP-[A-Z0-9-]+$/i.test(value) && (!idTp || value.toUpperCase() === idTp)) {
+        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] ?? positionalLiterals[0];
+        const raw = candidates[0];
         if (raw) {
-            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: value.length === 0
-                        ? "empty-string"
-                        : "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 };
-            }
-            return { kind: "unknown", text: raw };
+            return (observeLiteralToken(raw, field) ?? {
+                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 === "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 ||
@@ -538,37 +714,47 @@ function compareIntent(intent, observed, bound, example, field) {
         case "max":
             if (bound === undefined)
                 return "UNDETERMINED";
-            if (observed.kind === "string" && observed.length === bound)
-                return "MATCH";
-            // Writers may pass the exact length as a numeric positional instead of a repeated string.
-            if (observed.kind === "number" && Number(observed.literal) === bound)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "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 (observed.kind === "string" && observed.length === bound + 1)
-                return "MATCH";
-            if (observed.kind === "number" && Number(observed.literal) === bound + 1)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "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 (observed.kind === "string" && observed.length === bound)
-                return "MATCH";
-            if (observed.kind === "number" && Number(observed.literal) === bound)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "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);
-            if (observed.kind === "string" && observed.length === expectedMin1)
-                return "MATCH";
-            if (observed.kind === "number" && Number(observed.literal) === expectedMin1)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "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";
@@ -584,9 +770,16 @@ function compareIntent(intent, observed, bound, example, field) {
                     ? "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")) {
@@ -603,8 +796,36 @@ function compareIntent(intent, observed, bound, example, field) {
                     : "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"
@@ -670,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;
@@ -697,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, inferred.field);
+                : 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,

package/dist/workflows/dag/init-hybrid.js

@@ -3708,7 +3708,7 @@ async function buildBackendTestHybridDag(sources) {
         subtask_prompt: [
             "Perform one gap-targeted synchronization, not a full-suite rewrite or stylistic review. Start from explicit bound source IDs/error codes/DTO fields/normative quoted rules and the README Matrix; open and edit only modules that own a missing or conflicting rule. Preserve unrelated valid modules byte-for-byte and avoid optional wording cleanup.",
             "Output budget protocol: never dump full Matrix/case bodies into assistant chat. Inspect README first, build a concise target list, then read/write only target modules one file per tool call. Do not traverse every module when the Matrix and source token inventory show no gap; return `already-satisfied`. When adding omitted in-scope cases, keep every required section. Do not bulk-delete in-scope cases to save tokens.",
-            "For every variant Test Point, ensure the Markdown scenario intent is machine-checkable with an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target.",
+            "For every variant Test Point, ensure the Markdown scenario intent is machine-checkable with an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target. For intent=missing/empty/default-omit, pytest may use `_OMIT` or delete the key; for intent=enum-invalid use a concrete invalid enum literal (for example `UNKNOWN_STATUS`), never `_OMIT`/missing-key; for trim/padded samples use `custom-literal:trim` or a real padded string, not a bare token like `filter-active` when the intent is `custom-literal:ACTIVE`.",
             "Treat the requirement document as the coverage baseline; scope is limited to operations/rules it (or its referenced API contract) describes, and API contract evidence supplements scenario dimensions. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT. Directly add in-scope omissions; reject scope expansion to operations absent from the requirement document; undefined impact remains GAP/CONFLICT rather than invented behavior.",
             "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in `testcase/md/README.md`, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, and missing or drifted script/function mapping where it can be derived.",
             "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, ensure every binding-list Test Point is also present in that Case's `### 测试点`, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
@@ -3739,7 +3739,7 @@ async function buildBackendTestHybridDag(sources) {
         subtask_prompt: [
             "Convert testcase/md/** into pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. This node writes ONLY the shared pytest support assets (HTTP logging/redaction helper, request factories, shared fixtures); each module's test_<module>.py is written by a downstream sharded node that imports these helpers. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.",
             "Output budget protocol (hard, max output <=16K per turn): Write helpers/factories one file per write/edit tool call. Never paste full Python modules into assistant chat. Do not reduce params/assertions/skips semantics to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken shared files.",
-            "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them.",
+            "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize.",
             "Generate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. If shared pytest fixtures are generated, keep their dependency graph in one provider module and require each downstream test module to register that provider with an exact pytest_plugins tuple; importing only the outer fixture is insufficient and will be rejected by fixture-resolution preflight.",
             "HTTP response header names are case-insensitive. If the helper stores a lower-case normalized header map, every Content-Type or other header assertion must query the lower-case key (for example `content-type`) or use an explicitly case-insensitive accessor; never call a case-sensitive plain dict with `Content-Type` when the stored key is lower-case. Preserve the actual media-type assertion rather than dropping it.",
             "Compare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.",
@@ -3817,7 +3817,7 @@ async function buildBackendTestHybridDag(sources) {
                 subtaskPromptTemplate: [
                     "Convert the single Markdown module testcase/md/{{item.stem}}.md into one self-contained pytest module. After reading the module Markdown and the bounded pytest config/conftest, immediately use write tools to create the single file testcase/test_{{item.stem}}.py. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.",
                     "Output budget protocol (hard, max output <=16K per turn): Write exactly one test_{{item.stem}}.py. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.",
-                    "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them.",
+                    "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize.",
                     'Ensure every automatable final Markdown Case ID in this module appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. Skip evidence-only meta Cases that declare `脚本/primary symbol=无` with empty variants; do not invent a business pytest symbol for them. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id="TP-...")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use `pytest.param(..., id=...)` for every row; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). Implement request dictionaries so their direct and nested key paths and enum literals exactly satisfy the Case `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; for `Payload Contract: none`, do not invent a JSON/body DTO. No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task\'s explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.',
                     "Name the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly one `testcase/test_{{item.stem}}.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.",
                     "Keep this module self-contained: define module-local fixtures and helpers directly in testcase/test_{{item.stem}}.py, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.",

package/docs/templates/backend-test-dag.json

@@ -269,7 +269,7 @@
 				"type": "implementation-outcome-v1"
 			},
 			"outputContract": "First non-empty line is IMPLEMENTATION_OUTCOME: changed|already-satisfied|blocked. Perform exactly one bounded incremental synchronization of testcase/md/** against all bound source references; preserve valid Cases and report a concise summary.",
-			"subtask_prompt": "Perform one gap-targeted synchronization, not a full-suite rewrite or stylistic review. Start from explicit bound source IDs/error codes/DTO fields/normative quoted rules and the README Matrix; open and edit only modules that own a missing or conflicting rule. Preserve unrelated valid modules byte-for-byte and avoid optional wording cleanup.\n\nOutput budget protocol: never dump full Matrix/case bodies into assistant chat. Inspect README first, build a concise target list, then read/write only target modules one file per tool call. Do not traverse every module when the Matrix and source token inventory show no gap; return `already-satisfied`. When adding omitted in-scope cases, keep every required section. Do not bulk-delete in-scope cases to save tokens.\n\nFor every variant Test Point, ensure the Markdown scenario intent is machine-checkable with an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target.\n\nTreat the requirement document as the coverage baseline; scope is limited to operations/rules it (or its referenced API contract) describes, and API contract evidence supplements scenario dimensions. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT. Directly add in-scope omissions; reject scope expansion to operations absent from the requirement document; undefined impact remains GAP/CONFLICT rather than invented behavior.\n\nCheck AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in `testcase/md/README.md`, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, and missing or drifted script/function mapping where it can be derived.\n\nCorrect testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, ensure every binding-list Test Point is also present in that Case's `### 测试点`, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.\n\nThis is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; never infer missing keys or enum values. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.\n\nFor affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints.\n\nBefore returning, verify that every explicit source AC/REQ/BR, error code and strong DTO field token appears in README or an applicable module Case. If a fact cannot be safely automated, retain it as GAP/CONFLICT with its exact source pointer instead of dropping it. Return already-satisfied only when no target file needs an incremental edit.\n\nRead only indexed source paths. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails."
+			"subtask_prompt": "Perform one gap-targeted synchronization, not a full-suite rewrite or stylistic review. Start from explicit bound source IDs/error codes/DTO fields/normative quoted rules and the README Matrix; open and edit only modules that own a missing or conflicting rule. Preserve unrelated valid modules byte-for-byte and avoid optional wording cleanup.\n\nOutput budget protocol: never dump full Matrix/case bodies into assistant chat. Inspect README first, build a concise target list, then read/write only target modules one file per tool call. Do not traverse every module when the Matrix and source token inventory show no gap; return `already-satisfied`. When adding omitted in-scope cases, keep every required section. Do not bulk-delete in-scope cases to save tokens.\n\nFor every variant Test Point, ensure the Markdown scenario intent is machine-checkable with an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target. For intent=missing/empty/default-omit, pytest may use `_OMIT` or delete the key; for intent=enum-invalid use a concrete invalid enum literal (for example `UNKNOWN_STATUS`), never `_OMIT`/missing-key; for trim/padded samples use `custom-literal:trim` or a real padded string, not a bare token like `filter-active` when the intent is `custom-literal:ACTIVE`.\n\nTreat the requirement document as the coverage baseline; scope is limited to operations/rules it (or its referenced API contract) describes, and API contract evidence supplements scenario dimensions. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT. Directly add in-scope omissions; reject scope expansion to operations absent from the requirement document; undefined impact remains GAP/CONFLICT rather than invented behavior.\n\nCheck AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in `testcase/md/README.md`, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, and missing or drifted script/function mapping where it can be derived.\n\nCorrect testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, ensure every binding-list Test Point is also present in that Case's `### 测试点`, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.\n\nThis is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; never infer missing keys or enum values. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.\n\nFor affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints.\n\nBefore returning, verify that every explicit source AC/REQ/BR, error code and strong DTO field token appears in README or an applicable module Case. If a fact cannot be safely automated, retain it as GAP/CONFLICT with its exact source pointer instead of dropping it. Return already-satisfied only when no target file needs an incremental edit.\n\nRead only indexed source paths. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails."
 		},
 		{
 			"id": "validate-backend-md-cases-shell",
@@ -314,7 +314,7 @@
 				"artifacts/**"
 			],
 			"outputContract": "Deterministic pytest generation handoff. Per-module map children write self-contained test_<module>.py files with bounded local fixtures, HTTP logging/redaction and payload builders; no model invocation, JSON, shared-asset writes or pytest execution.",
-			"subtask_prompt": "Convert testcase/md/** into pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. This node writes ONLY the shared pytest support assets (HTTP logging/redaction helper, request factories, shared fixtures); each module's test_<module>.py is written by a downstream sharded node that imports these helpers. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.\n\nOutput budget protocol (hard, max output <=16K per turn): Write helpers/factories one file per write/edit tool call. Never paste full Python modules into assistant chat. Do not reduce params/assertions/skips semantics to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken shared files.\n\nAlign every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them.\n\nGenerate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. If shared pytest fixtures are generated, keep their dependency graph in one provider module and require each downstream test module to register that provider with an exact pytest_plugins tuple; importing only the outer fixture is insufficient and will be rejected by fixture-resolution preflight.\n\nHTTP response header names are case-insensitive. If the helper stores a lower-case normalized header map, every Content-Type or other header assertion must query the lower-case key (for example `content-type`) or use an explicitly case-insensitive accessor; never call a case-sensitive plain dict with `Content-Type` when the stored key is lower-case. Preserve the actual media-type assertion rather than dropping it.\n\nCompare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.\n\nBefore logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
+			"subtask_prompt": "Convert testcase/md/** into pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. This node writes ONLY the shared pytest support assets (HTTP logging/redaction helper, request factories, shared fixtures); each module's test_<module>.py is written by a downstream sharded node that imports these helpers. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.\n\nOutput budget protocol (hard, max output <=16K per turn): Write helpers/factories one file per write/edit tool call. Never paste full Python modules into assistant chat. Do not reduce params/assertions/skips semantics to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken shared files.\n\nAlign every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize.\n\nGenerate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. If shared pytest fixtures are generated, keep their dependency graph in one provider module and require each downstream test module to register that provider with an exact pytest_plugins tuple; importing only the outer fixture is insufficient and will be rejected by fixture-resolution preflight.\n\nHTTP response header names are case-insensitive. If the helper stores a lower-case normalized header map, every Content-Type or other header assertion must query the lower-case key (for example `content-type`) or use an explicitly case-insensitive accessor; never call a case-sensitive plain dict with `Content-Type` when the stored key is lower-case. Preserve the actual media-type assertion rather than dropping it.\n\nCompare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.\n\nBefore logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
 			"static": {
 				"resultMarkdown": "Shared pytest plan is deterministic: each downstream module writer owns one self-contained test_<module>.py and must not depend on generated shared helper/factory files."
 			}
@@ -420,7 +420,7 @@
 						]
 					},
 					"outputContract": "Write exactly one pytest module file testcase/test_<stem>.py whose actual test function region contains the exact Case ID, preferably in the function name or docstring. testcase/md/<module>.md (excluding README.md) maps one-to-one to testcase/test_<module>.py; never merge or split modules. No JSON and no pytest execution.",
-					"subtaskPromptTemplate": "Convert the single Markdown module testcase/md/{{item.stem}}.md into one self-contained pytest module. After reading the module Markdown and the bounded pytest config/conftest, immediately use write tools to create the single file testcase/test_{{item.stem}}.py. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.\n\nOutput budget protocol (hard, max output <=16K per turn): Write exactly one test_{{item.stem}}.py. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.\n\nAlign every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them.\n\nEnsure every automatable final Markdown Case ID in this module appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. Skip evidence-only meta Cases that declare `脚本/primary symbol=无` with empty variants; do not invent a business pytest symbol for them. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id=\"TP-...\")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use `pytest.param(..., id=...)` for every row; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). Implement request dictionaries so their direct and nested key paths and enum literals exactly satisfy the Case `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; for `Payload Contract: none`, do not invent a JSON/body DTO. No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task's explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.\n\nName the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly one `testcase/test_{{item.stem}}.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.\n\nKeep this module self-contained: define module-local fixtures and helpers directly in testcase/test_{{item.stem}}.py, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.\n\nMaterialize every automatable Markdown Case exactly once as one canonical primary pytest symbol. Preserve every explicit variant Test Point as a stable pytest.param id and every assertion/cross-cutting binding as declared. Build request payloads from the effective Markdown test data literally: keep all declared DTO keys, nested shapes, enum values, missing/null/boundary variants and business-state preconditions; never substitute guessed convenience fields or rename contract fields.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`."
+					"subtaskPromptTemplate": "Convert the single Markdown module testcase/md/{{item.stem}}.md into one self-contained pytest module. After reading the module Markdown and the bounded pytest config/conftest, immediately use write tools to create the single file testcase/test_{{item.stem}}.py. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.\n\nOutput budget protocol (hard, max output <=16K per turn): Write exactly one test_{{item.stem}}.py. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.\n\nAlign every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize.\n\nEnsure every automatable final Markdown Case ID in this module appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. Skip evidence-only meta Cases that declare `脚本/primary symbol=无` with empty variants; do not invent a business pytest symbol for them. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id=\"TP-...\")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use `pytest.param(..., id=...)` for every row; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). Implement request dictionaries so their direct and nested key paths and enum literals exactly satisfy the Case `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; for `Payload Contract: none`, do not invent a JSON/body DTO. No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task's explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.\n\nName the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly one `testcase/test_{{item.stem}}.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.\n\nKeep this module self-contained: define module-local fixtures and helpers directly in testcase/test_{{item.stem}}.py, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.\n\nMaterialize every automatable Markdown Case exactly once as one canonical primary pytest symbol. Preserve every explicit variant Test Point as a stable pytest.param id and every assertion/cross-cutting binding as declared. Build request payloads from the effective Markdown test data literally: keep all declared DTO keys, nested shapes, enum values, missing/null/boundary variants and business-state preconditions; never substitute guessed convenience fields or rename contract fields.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`."
 				}
 			}
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.33.7-beta.0",
+  "version": "0.33.7-beta.1",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",