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

package/CHANGELOG.md

@@ -3,12 +3,24 @@
 ## [Unreleased]
 
 ### 改进
+- scenario-param 识别 `"x" * _TITLE_MAX_LENGTH` 等长度表达式与 helper 常量名相乘形式
+- correspondence 忽略 pytest payload 中的 `expect`/`echo_*` 辅助键，避免把 DTO 外 helper 字段误判为 PAYLOAD_SHAPE_MISMATCH
+- scenario-param 解析 `bound=LEN100` 机器行、解引用 `_STATUS_ACTIVE` 等 Python 字符串常量，并把 `NOMINAL` 长度样本从 min/max 纠正为 nominal
 
 - 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.2] - 2026-08-13
+
+### Fixed
+- scenario-param 解析 `bound=LEN100`、解引用 `_STATUS_ACTIVE` 等 Python 字符串常量，识别 `"x" * _TITLE_MAX_LENGTH` 长度表达式
+- correspondence 忽略 pytest payload 中的 `expect`/`echo_*` 辅助键，避免假 PAYLOAD_SHAPE_MISMATCH
+
+### Changed
+- my-webapp 五轮 backend-test 全流程 live campaign 归档（R1–R5 均 finished；R5 correspondence PASS）
+
 ## [0.33.7-beta.1] - 2026-08-12
 
 ### Fixed

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

@@ -1152,6 +1152,9 @@ def collect_dict(node, prefix, paths, values):
     if not isinstance(node, ast.Dict): return
     for key,value in zip(node.keys,node.values):
         if not isinstance(key, ast.Constant) or not isinstance(key.value,str): continue
+        # Ignore writer helper/meta keys that are not DTO request fields.
+        if key.value in {'expect','expected','expected_status','expected_code','echo_title','echo_content','echo_status'} or key.value.startswith('echo_') or key.value.startswith('expected_'):
+            continue
         current = key.value if not prefix else prefix + '.' + key.value
         paths.add(current)
         lv=literal(value)

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

@@ -121,26 +121,43 @@ async function listMarkdownCases(workspaceRoot) {
     }
     return cases;
 }
+function parseScenarioBoundToken(raw) {
+    if (!raw)
+        return undefined;
+    const token = raw.trim();
+    if (!token || /^LEN<nominal>$/i.test(token) || /^NOMINAL$/i.test(token)) {
+        return undefined;
+    }
+    const direct = Number(token);
+    if (Number.isFinite(direct) && direct >= 0)
+        return direct;
+    const len = /^(?:LEN(?:GTH)?[_-]?)?(\d{1,5})$/i.exec(token);
+    if (len) {
+        const n = Number(len[1]);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    return undefined;
+}
 function parseScenarioIntentLine(line) {
     // Target may contain commas (body.title,body.status). Intent may contain `|` / spaces.
     // Stop field values only at known trailing keys or end-of-line.
-    const precise = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;]\s*operation\s*=\s*([^;\n]+?)\s*[|;]\s*target\s*=\s*([^;\n]+?)\s*[|;]\s*intent\s*=\s*(.+?)(?:\s*[|;]\s*bound\s*=\s*(\d+))?(?:\s*[|;]\s*example\s*=\s*([^;\n]+))?(?:\s*[|;]\s*expectedCode\s*=\s*[^;\n]+)?\s*$/i.exec(line.trim());
+    const precise = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;]\s*operation\s*=\s*([^;\n]+?)\s*[|;]\s*target\s*=\s*([^;\n]+?)\s*[|;]\s*intent\s*=\s*([^;\n]+?)(?:\s*[|;]\s*bound\s*=\s*([^\s;|\n]+))?(?:\s*[|;]\s*example\s*=\s*([^;\n]+))?(?:\s*[|;]\s*expectedCode\s*=\s*[^;\n]+)?\s*$/i.exec(line.trim());
     if (precise) {
         return {
             tpId: precise[1],
             rawIntent: (precise[4] ?? "unknown").trim(),
             target: precise[3]?.trim(),
-            bound: precise[5] ? Number(precise[5]) : undefined,
+            bound: parseScenarioBoundToken(precise[5]),
             example: precise[6]?.trim(),
             legacy: false,
         };
     }
-    const legacy = /场景意图\s*[:：]\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(line.trim());
+    const legacy = /场景意图\s*[:：]\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*([^\s;|,，\n]+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(line.trim());
     if (legacy) {
         return {
             rawIntent: (legacy[1] ?? "unknown").trim(),
             field: legacy[2],
-            bound: legacy[3] ? Number(legacy[3]) : undefined,
+            bound: parseScenarioBoundToken(legacy[3]),
             example: legacy[4]?.trim(),
             legacy: true,
         };
@@ -220,7 +237,13 @@ export function inferScenarioParamIntent(input) {
         const rawIntent = machine.rawIntent.trim();
         const example = machine.example;
         const lower = rawIntent.toLowerCase();
-        const normalizedIntent = lower === "nominal-operation" ? "nominal" : lower;
+        let normalizedIntent = lower === "nominal-operation" ? "nominal" : lower;
+        // Writers sometimes mark a short "typical" length sample as min/max with bound=LEN<nominal>.
+        // Treat that as nominal so a short helper/string is not forced to equal maxLength.
+        if ((normalizedIntent === "min" || normalizedIntent === "max") &&
+            /NOMINAL/i.test(tpId)) {
+            normalizedIntent = "nominal";
+        }
         const dataSection = sectionBody(caseBody, ["测试数据", "Test Data", "操作步骤", "Steps"]);
         const haystack = `${caseBody}\n${dataSection}`;
         const fieldEsc = field
@@ -315,6 +338,24 @@ export function inferScenarioParamIntent(input) {
         "HTTP",
         "RESPONSE",
         "REQUEST",
+        "NOTES",
+        "NOTE",
+        "REQUIRED",
+        "LENGTH",
+        "OVER",
+        "FILTER",
+        "LIST",
+        "ROUNDTRIP",
+        "READINESS",
+        "DEFAULT",
+        "TRIM",
+        "BLANK",
+        "WHITESPACE",
+        "NORMALIZE",
+        "FAIL",
+        "SUCCESS",
+        "LOWERCASE",
+        "UPPERCASE",
     ].includes(part.toUpperCase()))[0]
         ?.replace(/_/g, "") ?? undefined;
     const field = fieldFromTp && fieldFromTp.length > 1
@@ -340,7 +381,7 @@ export function inferScenarioParamIntent(input) {
     if (/\bNULL\b|空值/.test(upper) || /\bnull\b/i.test(caseBody)) {
         return { intent: "null", field, bound, example, intentSource: "tp-fallback" };
     }
-    if (/MAX[-_]?PLUS[-_]?1|MAX\+1|超长|越界/.test(upper)) {
+    if (/MAX[-_]?PLUS[-_]?1|MAX\+1|超长|越界|LENGTH[-_]?OVER|OVER[-_]?LENGTH|OVER/.test(upper)) {
         return { intent: "max+1", field, bound, example, intentSource: "tp-fallback" };
     }
     if (/\bMAX\b|最大/.test(upper)) {
@@ -423,7 +464,25 @@ function featuresFromStringValue(value) {
         literal: decoded,
     };
 }
-function observeLiteralToken(raw, field) {
+function collectPythonStringConstants(source) {
+    const constants = new Map();
+    const re = /\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(["'])([^"'\\]*)\2/g;
+    let match;
+    while ((match = re.exec(source)) !== null) {
+        const name = match[1] ?? "";
+        const value = match[3] ?? "";
+        if (name && !constants.has(name))
+            constants.set(name, value);
+    }
+    return constants;
+}
+function resolveNamedConstant(name, constants) {
+    if (!constants?.has(name))
+        return undefined;
+    const value = constants.get(name) ?? "";
+    return featuresFromStringValue(value);
+}
+function observeLiteralToken(raw, field, constants) {
     const trimmed = raw.trim();
     if (!trimmed)
         return undefined;
@@ -446,6 +505,35 @@ function observeLiteralToken(raw, field) {
         const value = ch.repeat(Math.max(0, length));
         return featuresFromStringValue(value);
     }
+    // "x" * _TITLE_MAX_LENGTH / "a" * _TITLE_LEN100
+    const repeatedConst = /^(['"])([^'"\\])\1\s*\*\s*([A-Za-z_][A-Za-z0-9_]*)$/.exec(trimmed);
+    if (repeatedConst) {
+        const helper = repeatedConst[3] ?? "";
+        const fromConst = resolveNamedConstant(helper, constants);
+        if (fromConst?.kind === "string" && typeof fromConst.length === "number") {
+            return {
+                kind: "number",
+                text: trimmed,
+                length: fromConst.length,
+                literal: String(fromConst.length),
+            };
+        }
+        const lenFromName = /(?:^|_)LEN(?:GTH)?_?(\d{1,5})$/i.exec(helper) ??
+            /LEN(?:GTH)?_?(\d{1,5})$/i.exec(helper);
+        if (lenFromName) {
+            const length = Number(lenFromName[1] ?? "0");
+            return { kind: "number", text: trimmed, length, literal: String(length) };
+        }
+        if (/(?:OVER|OVERSIZE|TOO[_-]?LONG|MAX[_-]?PLUS[_-]?1|MAXPLUS1)/i.test(helper)) {
+            return { kind: "name", text: helper, length: -2, literal: "oversize-helper" };
+        }
+        if (/(?:MAX[_-]?LENGTH|LENGTH[_-]?MAX|_MAX_LEN(?:GTH)?$)/i.test(helper)) {
+            return { kind: "name", text: helper, length: -1, literal: "max-length-helper" };
+        }
+        if (/(?:MIN[_-]?LENGTH|LENGTH[_-]?MIN|_MIN_LEN(?:GTH)?$)/i.test(helper)) {
+            return { kind: "name", text: helper, length: -3, literal: "min-length-helper" };
+        }
+    }
     const triple = /^("""|''')([\s\S]*)\1$/.exec(trimmed);
     if (triple) {
         return featuresFromStringValue(triple[2] ?? "");
@@ -469,7 +557,7 @@ function observeLiteralToken(raw, field) {
         const inner = trimmed.replace(/^\(/, "").replace(/\)$/, "");
         const first = inner.split(",")[0]?.trim();
         if (first && first !== trimmed) {
-            return observeLiteralToken(first, field);
+            return observeLiteralToken(first, field, constants);
         }
         return { kind: "call", text: trimmed };
     }
@@ -503,6 +591,9 @@ function observeLiteralToken(raw, field) {
         if (/(?:MIN[_-]?LENGTH|LENGTH[_-]?MIN|_MIN_LEN(?:GTH)?$)/i.test(trimmed)) {
             return { kind: "name", text: trimmed, length: -3, literal: "min-length-helper" };
         }
+        const resolved = resolveNamedConstant(trimmed, constants);
+        if (resolved)
+            return resolved;
         return { kind: "name", text: trimmed };
     }
     return { kind: "unknown", text: trimmed };
@@ -534,7 +625,7 @@ export function extractPytestParamBlock(source, tpId) {
     }
     return undefined;
 }
-export function observeParamFeatures(block, field) {
+export function observeParamFeatures(block, field, constants) {
     if (!block)
         return { kind: "unknown", text: "param-block-missing" };
     const compact = block.replace(/\s+/g, " ");
@@ -563,7 +654,7 @@ export function observeParamFeatures(block, field) {
         }
         const valueMatch = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*([^,}\n]+)`).exec(dictText);
         const raw = valueMatch?.[1]?.trim() ?? "";
-        return (observeLiteralToken(raw, field) ?? {
+        return (observeLiteralToken(raw, field, constants) ?? {
             kind: "unknown",
             text: raw || compact.slice(0, 120),
         });
@@ -597,7 +688,7 @@ export function observeParamFeatures(block, field) {
     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;
+        const tokenRe = /\s*(_OMIT|OMIT|MISSING|Ellipsis|\.\.\.|None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'|(?:["'][^"'\\]["']\s*\*\s*(?:\d{1,5}|[A-Za-z_][A-Za-z0-9_]*))|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[A-Za-z_][A-Za-z0-9_]*)\s*(?:,|\)|$)/g;
         let match;
         while ((match = tokenRe.exec(afterOpen)) !== null) {
             const between = afterOpen.slice(0, match.index);
@@ -612,7 +703,7 @@ export function observeParamFeatures(block, field) {
         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);
+            const observed = observeLiteralToken(raw, field, constants);
             if (!observed)
                 return false;
             if (observed.kind === "string" &&
@@ -632,7 +723,7 @@ export function observeParamFeatures(block, field) {
         });
         const raw = candidates[0];
         if (raw) {
-            return (observeLiteralToken(raw, field) ?? {
+            return (observeLiteralToken(raw, field, constants) ?? {
                 kind: "unknown",
                 text: raw,
             });
@@ -925,15 +1016,21 @@ export async function assessBackendScenarioParamConsistency(input) {
                 caseBody: testCase.body,
             });
             const fallbackSourced = inferred.intentSource === "tp-fallback";
+            const constants = source ? collectPythonStringConstants(source) : undefined;
             const block = source ? extractPytestParamBlock(source, tpId) : undefined;
-            const observed = observeParamFeatures(block, inferred.field);
-            // 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 observed = observeParamFeatures(block, inferred.field, constants);
+            // Request-level / health checks often have no pytest.param payload row,
+            // or only a TP-id label positional (no field value).
             const requestLevelNoParam = Boolean(source) &&
-                !block &&
-                observed.text === "param-block-missing" &&
-                (inferred.intent === "nominal" || inferred.intent === "unknown");
+                (inferred.intent === "nominal" || inferred.intent === "unknown") &&
+                ((!block && observed.text === "param-block-missing") ||
+                    (Boolean(block) &&
+                        !inferred.field &&
+                        (observed.kind === "unknown" ||
+                            observed.kind === "missing-key" ||
+                            (observed.kind === "string" &&
+                                Boolean(observed.literal) &&
+                                /^TP-[A-Z0-9-]+$/i.test(observed.literal ?? "")))));
             const status = !source
                 ? "UNDETERMINED"
                 : requestLevelNoParam

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

@@ -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. 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.",
+            "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. Hard contract: request payload dicts may only contain DTO field keys from Payload Allowed Paths; never put expect/expected/echo_* helper keys inside the JSON body dict.",
             "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. 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.",
+                    "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. Hard contract: request payload dicts may only contain DTO field keys from Payload Allowed Paths; never put expect/expected/echo_* helper keys inside the JSON body dict.",
                     '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/package.json

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