@tea-agent/loop-agent 0.42.0-next.7 → 0.42.0-next.9

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

@@ -307,14 +307,18 @@ export function classifyBackendTestCorrespondenceRepair(facts, layout) {
         const markdownReasons = [];
         const pytestReasons = [];
         const counts = bindingCounts(entry);
-        if (entry.testPoints.some((point) => (counts.get(point) ?? 0) !== 1) ||
-            [...counts.keys()].some((point) => !entry.testPoints.includes(point))) {
+        if (entry.cardinality !== "0:1" &&
+            entry.testPoints.some((point) => (counts.get(point) ?? 0) !== 1)) {
+            // Only ### 测试点 inventory must be bound exactly once. Extra
+            // automation-mapping TPs (typical: 横切 listed only under 跨切证据)
+            // are pytest-owned docstring/repair defects, not Markdown BLOCKED.
             markdownReasons.push("markdown-test-point-binding-invalid");
         }
         if (entry.declaredScript && entry.declaredScript !== entry.expectedScript) {
             markdownReasons.push("markdown-script-declaration-invalid");
         }
-        if (entry.cardinality === "1:0")
+        const evidenceOnly = isEvidenceOnlyCorrespondenceEntry(entry);
+        if (!evidenceOnly && entry.cardinality === "1:0")
             pytestReasons.push("missing-pytest-symbol");
         if (entry.cardinality === "1:N")
             pytestReasons.push("multiple-pytest-symbols");
@@ -325,12 +329,15 @@ export function classifyBackendTestCorrespondenceRepair(facts, layout) {
         if (entry.declaredPrimarySymbol && entry.pytestSymbols.some((symbol) => symbol !== entry.declaredPrimarySymbol)) {
             pytestReasons.push("pytest-primary-symbol-mismatch");
         }
-        if (entry.variantTestPoints.some((point) => !entry.parameterIds.includes(point)))
+        if (!evidenceOnly && entry.variantTestPoints.some((point) => !entry.parameterIds.includes(point))) {
             pytestReasons.push("variant-parameter-missing");
-        if (entry.assertionTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+        }
+        if (!evidenceOnly && entry.assertionTestPoints.some((point) => !entry.mappedTestPoints.includes(point))) {
             pytestReasons.push("assertion-binding-missing");
-        if (entry.crossCuttingTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+        }
+        if (!evidenceOnly && entry.crossCuttingTestPoints.some((point) => !entry.mappedTestPoints.includes(point))) {
             pytestReasons.push("cross-cutting-binding-missing");
+        }
         if (entry.parameterIds.some((point) => !entry.testPoints.includes(point)))
             pytestReasons.push("pytest-test-point-binding-extra");
         if (entry.payloadAssessment.status === "UNSAFE")
@@ -339,7 +346,7 @@ export function classifyBackendTestCorrespondenceRepair(facts, layout) {
             !["TEST_POINT_BINDING_DUPLICATE", "PAYLOAD_CONTRACT_UNAVAILABLE"].includes(entry.status)) {
             pytestReasons.push(`correspondence-${entry.status.toLowerCase().replaceAll("_", "-")}`);
         }
-        if (entry.status === "PAYLOAD_CONTRACT_UNAVAILABLE") {
+        if (entry.status === "PAYLOAD_CONTRACT_UNAVAILABLE" && entry.cardinality !== "0:1") {
             markdownReasons.push("markdown-payload-contract-unavailable");
         }
         const paths = orderedUnique([entry.expectedScript, ...entry.actualScripts].filter(safePytestPath));
@@ -796,6 +803,16 @@ function isEvidenceOnlyMarkdownCase(testCase) {
         !hasVariant &&
         hasNonVariant);
 }
+function isEvidenceOnlyCorrespondenceEntry(entry) {
+    return (entry.status === "EXACT_1_TO_1" &&
+        entry.cardinality === "1:0" &&
+        !entry.declaredScript &&
+        !entry.declaredPrimarySymbol &&
+        entry.variantTestPoints.length === 0 &&
+        (entry.assertionTestPoints.length > 0 || entry.crossCuttingTestPoints.length > 0) &&
+        entry.pytestSymbols.length === 0 &&
+        entry.actualScripts.length === 0);
+}
 function payloadContract(body) {
     const contractValue = automationLabelBody(body, ["Payload Contract", "载荷合同"]);
     const requiredValue = automationLabelBody(body, ["Payload Required Paths", "载荷必需路径"]);
@@ -804,7 +821,7 @@ function payloadContract(body) {
     const tokens = (value) => orderedUnique(value
         .split(/[,;，；]/)
         .map((item) => item.trim())
-        .filter((item) => !/^(?:none|无|not-applicable|n\/a)$/i.test(item))
+        .filter((item) => !/^(?:none|无|not-applicable|n\/a|true|false)$/i.test(item))
         .filter((item) => /^[A-Za-z_][A-Za-z0-9_.]*$/.test(item)));
     const enumValues = {};
     for (const assignment of enumValue.split(/[,;，；]/).map((item) => item.trim()).filter(Boolean)) {
@@ -1465,6 +1482,13 @@ for top in ast.walk(tree):
                 for keyword in node.keywords:
                     if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
                         transport.append((keyword.value.id,positional.index(keyword.value.id)-call_offset))
+                    if keyword.arg is None and isinstance(keyword.value,ast.Name):
+                        alias=keyword.value.id
+                        assigned_value=assigned.get(alias)
+                        if isinstance(assigned_value,ast.Name) and assigned_value.id in positional:
+                            transport.append((assigned_value.id,positional.index(assigned_value.id)-call_offset))
+                        elif isinstance(assigned_value,ast.Call) and isinstance(assigned_value.func,ast.Name) and assigned_value.func.id == 'dict' and assigned_value.args and isinstance(assigned_value.args[0],ast.Name) and assigned_value.args[0].id in positional:
+                            transport.append((assigned_value.args[0].id,positional.index(assigned_value.args[0].id)-call_offset))
                 if isinstance(node.func,ast.Attribute) and node.func.attr.lower() in {'post','put','patch'} and len(node.args) >= 2:
                     candidate=node.args[1]
                     if isinstance(candidate,ast.Name) and candidate.id in positional:
@@ -1476,6 +1500,17 @@ for top in ast.walk(tree):
                     matched=node.args[nested_position] if nested_position >= 0 and nested_position < len(node.args) else None
                     if isinstance(matched,ast.Name) and matched.id in positional:
                         transport.append((matched.id,positional.index(matched.id)-call_offset))
+        # Assignment order in ast.walk is not source order. Re-scan **kwargs
+        # aliases once the complete local assignment table is available.
+        for node in ast.walk(top):
+            if not isinstance(node,ast.Call): continue
+            for keyword in node.keywords:
+                if keyword.arg is not None or not isinstance(keyword.value,ast.Name): continue
+                assigned_value=assigned.get(keyword.value.id)
+                if isinstance(assigned_value,ast.Name) and assigned_value.id in positional:
+                    transport.append((assigned_value.id,positional.index(assigned_value.id)-call_offset))
+                elif isinstance(assigned_value,ast.Call) and isinstance(assigned_value.func,ast.Name) and assigned_value.func.id == 'dict' and assigned_value.args and isinstance(assigned_value.args[0],ast.Name) and assigned_value.args[0].id in positional:
+                    transport.append((assigned_value.args[0].id,positional.index(assigned_value.args[0].id)-call_offset))
         for returned_name in returned_names:
             entries=mutated.get(returned_name,[])
             if entries:
@@ -1705,6 +1740,20 @@ def is_direct_transport_call(node):
     if isinstance(current,ast.Name): receiver_tokens.append(current.id.lower())
     return any(token in {'requests','httpx','client','session','api_client','http_client'} or token.endswith('_client') for token in receiver_tokens)
 
+HTTP_METHODS={'GET','POST','PUT','PATCH','DELETE','HEAD','OPTIONS'}
+HTTP_FIXTURE_NAMES={'http','http_client','client','api_client','session'}
+
+def is_fixture_http_call(node):
+    # R12: http("POST", path, json_body={"title": title}) is a Name-call fixture, not client.post.
+    # R15: http_client(operation, path, json_body={...}) still transports when operation is a parametrized method.
+    if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Name) or not node.args: return False
+    first=node.args[0]
+    if isinstance(first,ast.Constant) and isinstance(first.value,str) and first.value.upper() in HTTP_METHODS:
+        return True
+    func=node.func.id.lower()
+    httpish=func in HTTP_FIXTURE_NAMES or func.endswith('_client')
+    return httpish and isinstance(first,ast.Name)
+
 def payload_nodes(fn):
     result=[]
     assigned={}
@@ -1727,7 +1776,7 @@ def payload_nodes(fn):
     # Observe local payload/body variables only when they flow into a direct
     # HTTP transport call. Arbitrary setup variables are not target requests.
     for node in ast.walk(fn):
-        if not is_direct_transport_call(node): continue
+        if not (is_direct_transport_call(node) or is_fixture_http_call(node)): continue
         for keyword in node.keywords:
             if keyword.arg in PAYLOAD_NAMES: result.extend(payload_expr_nodes(keyword.value,assigned,parameters))
     return result

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

@@ -59,6 +59,7 @@ const CLOSED_SET = new Set([
     "null",
     "min-1",
     "min",
+    "max-1",
     "max",
     "max+1",
     "pattern-invalid",
@@ -155,14 +156,19 @@ function parseScenarioBoundToken(raw) {
 function parseScenarioIntentLine(line) {
     // Target may contain commas (body.title,body.status). Intent may contain `|` / spaces.
     // Stop field values only at known trailing keys or end-of-line.
-    const precise = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;]\s*operation\s*=\s*([^;\n]+?)\s*[|;]\s*target\s*=\s*([^;\n]+?)\s*[|;]\s*intent\s*=\s*([^;\n]+?)(?:\s*[|;]\s*bound\s*=\s*([^\s;|\n]+))?(?:\s*[|;]\s*example\s*=\s*([^;\n]+))?(?:\s*[|;]\s*expectedCode\s*=\s*[^;\n]+)?\s*$/i.exec(line.trim());
+    const unfenced = line
+        .trim()
+        .replace(/^[-*+]\s+/, "")
+        .replace(/^`(.+)`$/, "$1")
+        .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(unfenced);
     if (precise) {
         return {
             tpId: precise[1],
             rawIntent: (precise[4] ?? "unknown").trim(),
             target: precise[3]?.trim(),
             bound: parseScenarioBoundToken(precise[5]),
-            example: precise[6]?.trim(),
+            example: precise[6] === undefined ? undefined : precise[6].trim(),
             legacy: false,
         };
     }
@@ -192,6 +198,53 @@ function resolveScenarioIntentField(target, field) {
         target.split(/\s*,\s*/)[0];
     return preferred?.split(".").at(-1);
 }
+function normalizeLengthIntentAlias(rawIntent) {
+    const lower = rawIntent.trim().toLowerCase();
+    if (lower === "max-1" || lower === "maxminus1" || lower === "max_minus_1") {
+        return "max-1";
+    }
+    if (lower === "min-1" || lower === "minminus1" || lower === "min_minus_1") {
+        return "min-1";
+    }
+    return lower;
+}
+function proseLengthBound(haystack, field) {
+    const fieldAlt = field ? field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : undefined;
+    const scoped = fieldAlt ? new RegExp(`${fieldAlt}[^\\n]{0,160}`, "ig") : undefined;
+    const windows = [];
+    if (scoped) {
+        for (const match of haystack.matchAll(scoped)) {
+            windows.push(match[0] ?? "");
+        }
+    }
+    windows.push(haystack);
+    let max;
+    let min;
+    const proseMaxRe = /(\d{1,4})\s*个字符的最大/i;
+    for (const window of windows) {
+        const proseMax = proseMaxRe.exec(window);
+        if (proseMax && max === undefined)
+            max = Number(proseMax[1]);
+        const nums = [...window.matchAll(/(?<![+\-])\d{1,4}/g)]
+            .map((item) => Number(item[0]))
+            .filter((item) => Number.isFinite(item));
+        for (let i = 0; i + 2 < nums.length; i += 1) {
+            const a = nums[i];
+            const b = nums[i + 1];
+            const c = nums[i + 2];
+            // Prefer n-1,n,n+1 around a documented max (100/2000), not 0,1,99 or 99,100,101's first two plus leftover.
+            if (b === a + 1 && c === b + 1 && b >= 10) {
+                max ??= b;
+                break;
+            }
+        }
+        if (nums.includes(0) && nums.includes(1))
+            min ??= 1;
+        if (max !== undefined && min !== undefined)
+            break;
+    }
+    return { max, min };
+}
 function resolveCustomLiteralIntent(rawIntent, field) {
     const lower = rawIntent.toLowerCase();
     if (!lower.startsWith("custom-literal:")) {
@@ -250,7 +303,7 @@ export function inferScenarioParamIntent(input) {
         const field = resolveScenarioIntentField(machine.target, machine.field);
         const rawIntent = machine.rawIntent.trim();
         const example = machine.example;
-        const lower = rawIntent.toLowerCase();
+        const lower = normalizeLengthIntentAlias(rawIntent);
         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.
@@ -273,16 +326,16 @@ export function inferScenarioParamIntent(input) {
                 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 proseBound = proseLengthBound(haystack, field);
         const prefersMinBound = normalizedIntent === "min" ||
             normalizedIntent === "min-1" ||
             /(?:MIN|LEN1|LENGTH-?1|最短|最小)/i.test(tpId);
-        const boundFromBody = prefersMinBound
-            ? minBoundFromBody ?? maxBoundFromBody
-            : maxBoundFromBody ?? minBoundFromBody;
+        const boundFromBody = prefersMinBound ? minBoundFromBody : maxBoundFromBody ?? minBoundFromBody;
         const boundFromTp = /(?:LEN(?:GTH)?|长度)[_-]?(\d{1,5})(?:[_-]|$)/i.exec(tpId) ??
-            /(?:MIN|MAX)[_-]?(\d{1,5})(?:[_-]|$)/i.exec(tpId);
+            /(?:MIN|MAX)[_-](\d{2,5})(?:[_-]|$)/i.exec(tpId);
         const lengthIntent = normalizedIntent === "min" ||
             normalizedIntent === "min-1" ||
+            normalizedIntent === "max-1" ||
             normalizedIntent === "max" ||
             normalizedIntent === "max+1";
         // Length intents: explicit machine bound >0, then TP-encoded LEN1/LEN100,
@@ -294,13 +347,35 @@ export function inferScenarioParamIntent(input) {
             : normalizedIntent === "max+1"
                 ? Math.max(0, boundFromTpNumber - 1)
                 : boundFromTpNumber;
-        const bound = machine.bound && machine.bound > 0
-            ? machine.bound
-            : lengthIntent && boundFromTpNormalized !== undefined
-                ? boundFromTpNormalized
-                : boundFromBody
-                    ? Number(boundFromBody[1])
-                    : machine.bound;
+        const boundFromProse = prefersMinBound ? proseBound.min : proseBound.max;
+        const offsetIntent = normalizedIntent === "max-1" ||
+            normalizedIntent === "max+1" ||
+            normalizedIntent === "min-1";
+        const contractBound = boundFromBody
+            ? Number(boundFromBody[1])
+            : boundFromProse !== undefined && boundFromProse >= 0
+                ? boundFromProse
+                : undefined;
+        const machineBoundPositive = typeof machine.bound === "number" && Number.isFinite(machine.bound) && machine.bound > 0;
+        const minLengthFromBody = prefersMinBound && minBoundFromBody ? Number(minBoundFromBody[1]) : undefined;
+        const machineBoundZeroMin = prefersMinBound &&
+            machine.bound === 0 &&
+            minLengthFromBody === undefined &&
+            boundFromTpNormalized === undefined;
+        const bound = offsetIntent && contractBound !== undefined && contractBound > 0
+            ? contractBound
+            : machineBoundPositive && !offsetIntent
+                ? machine.bound
+                : lengthIntent && boundFromTpNormalized !== undefined
+                    ? boundFromTpNormalized
+                    : minLengthFromBody !== undefined && minLengthFromBody >= 0
+                        ? minLengthFromBody
+                        : machineBoundZeroMin
+                            ? 0
+                            : contractBound !== undefined &&
+                                (prefersMinBound ? contractBound >= 0 : contractBound > 0)
+                                ? contractBound
+                                : undefined;
         if (rawIntent.toLowerCase().startsWith("custom-literal:")) {
             const resolved = resolveCustomLiteralIntent(rawIntent, field);
             const rawLiteral = rawIntent.slice(rawIntent.indexOf(":") + 1).trim();
@@ -387,13 +462,15 @@ export function inferScenarioParamIntent(input) {
     const boundMatch = fieldScopedBound ??
         /(?:maxLength|max(?:imum)?|上限|最大长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`) ??
         /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`);
-    const bound = boundMatch ? Number(boundMatch[1]) : undefined;
+    const proseBound = proseLengthBound(`${caseBody}
+${dataSection}`, field);
+    const bound = boundMatch ? Number(boundMatch[1]) : proseBound.max ?? proseBound.min;
     const exampleMatch = /(?:反例|invalid example|example)\s*[=:：]\s*[`"]?([^`"\n]+)[`"]?/i.exec(caseBody);
     const example = exampleMatch?.[1]?.trim();
     if (/EMPTY|空白|空串|空字符串/.test(upper) || /空字符串|空串|empty string/i.test(caseBody)) {
         return { intent: "empty", field, bound, example, intentSource: "tp-fallback" };
     }
-    if (/MISSING|缺省|缺失|省略/.test(upper) || /缺少字段|缺失字段|missing field/i.test(caseBody)) {
+    if (/MISSING|OMITTED|\bOMIT\b|缺省|缺失|省略/.test(upper) || /缺少字段|缺失字段|missing field/i.test(caseBody)) {
         return { intent: "missing", field, bound, example, intentSource: "tp-fallback" };
     }
     if (/\bNULL\b|空值/.test(upper) || /\bnull\b/i.test(caseBody)) {
@@ -402,6 +479,9 @@ export function inferScenarioParamIntent(input) {
     if (/MAX[-_]?PLUS[-_]?1|MAX\+1|超长|越界|LENGTH[-_]?OVER|OVER[-_]?LENGTH|OVER/.test(upper)) {
         return { intent: "max+1", field, bound, example, intentSource: "tp-fallback" };
     }
+    if (/MAX[-_]1(?:$|[-_])|max-1/i.test(upper)) {
+        return { intent: "max-1", field, bound, example, intentSource: "tp-fallback" };
+    }
     if (/\bMAX\b|最大/.test(upper)) {
         return { intent: "max", field, bound, example, intentSource: "tp-fallback" };
     }
@@ -425,7 +505,7 @@ export function inferScenarioParamIntent(input) {
     }
     return { intent: "unknown", field, bound, example, intentSource: "tp-fallback" };
 }
-const OMIT_SENTINEL_RE = /^(?:_OMIT|OMIT|MISSING|Ellipsis|\.\.\.)\b/;
+const OMIT_SENTINEL_RE = /^(?:_OMIT|_MISSING|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) {
@@ -774,6 +854,10 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
         (/["'][A-Za-z_][A-Za-z0-9_]*["']\s*:/.test(dictText) ||
             /(?:payload|body|data|json)\s*=/.test(block));
     if (dictLooksLikePayload && !field) {
+        const emptyField = /["']([A-Za-z_][A-Za-z0-9_.]*)["']\s*:\s*(?:""|'')/.exec(dictText);
+        if (emptyField?.[1]) {
+            return { kind: "empty-string", text: '""', length: 0, literal: "" };
+        }
         return { kind: "dict", text: dictText.replace(/\s+/g, " ").slice(0, 160) };
     }
     if (dictLooksLikePayload && field) {
@@ -803,7 +887,7 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
         };
     }
     // Bare omit sentinel before id=...
-    if (/pytest\.param\s*\(\s*(?:_OMIT|OMIT|MISSING|\.\.\.|Ellipsis)\s*(?:,|\)|$)/.test(block)) {
+    if (/pytest\.param\s*\(\s*(?:_OMIT|_MISSING|OMIT|MISSING|\.\.\.|Ellipsis)\s*(?:,|\)|$)/.test(block)) {
         return {
             kind: "missing-key",
             text: field ? `missing:${field}` : "missing-key",
@@ -865,7 +949,7 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
     if (paramOpen) {
         const afterOpen = block.slice((paramOpen.index ?? 0) + paramOpen[0].length);
         const positionalTokens = [];
-        const tokenRe = /\s*(_OMIT|OMIT|MISSING|Ellipsis|\.\.\.|None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'|(?:["'][^"'\\]["']\s*\*\s*(?:\d{1,5}|[A-Za-z_][A-Za-z0-9_]*))|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[A-Za-z_][A-Za-z0-9_]*)\s*(?:,|\)|$)/g;
+        const tokenRe = /\s*(_OMIT|_MISSING|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);
@@ -1008,12 +1092,25 @@ function compareIntent(intent, observed, bound, example, field) {
                     return "MATCH";
                 return len !== undefined ? "MISMATCH" : "UNDETERMINED";
             }
+        case "max-1":
+            if (bound === undefined)
+                return "UNDETERMINED";
+            {
+                const expectedMax1 = Math.max(0, bound - 1);
+                const len = observedLengthValue(observed);
+                if (len === expectedMax1)
+                    return "MATCH";
+                return len !== undefined ? "MISMATCH" : "UNDETERMINED";
+            }
         case "min":
             if (bound === undefined)
                 return "UNDETERMINED";
             {
                 if (isMinLengthHelper(observed))
                     return "MATCH";
+                // Optional min=0 may omit the key instead of sending "".
+                if (bound === 0 && observed.kind === "missing-key")
+                    return "MATCH";
                 const len = observedLengthValue(observed);
                 if (len === bound)
                     return "MATCH";
@@ -1167,6 +1264,10 @@ function suggestedFixFor(intent, field, bound, example) {
             return field && bound !== undefined
                 ? `set ${field}="x"*${bound + 1}`
                 : undefined;
+        case "max-1":
+            return field && bound !== undefined
+                ? `set ${field}="x"*${Math.max(0, bound - 1)}`
+                : undefined;
         case "min":
             return field && bound !== undefined
                 ? `set ${field}="x"*${bound}`
@@ -1375,6 +1476,32 @@ function hasSafeSameModulePayloadHelper(source, block, parameterNames) {
         return false;
     return Boolean(safeSameModuleDictHelper(source, call.name));
 }
+function observeBranchPayloadField(input) {
+    const region = scenarioFunctionRegion(input.source, input.tpId);
+    if (!region || !input.block)
+        return undefined;
+    const args = extractPytestParamTopLevelArgs(input.block);
+    const escapedField = input.field.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+    for (let index = 0; index < input.parameterNames.length; index += 1) {
+        const parameter = input.parameterNames[index];
+        const raw = args[index]?.trim();
+        if (!raw || !/^['\"](?:[^'\"\\\\]|\\\\.)*['\"]$/.test(raw))
+            continue;
+        const branchValue = raw.slice(1, -1).replace(/\\\\([\\\"'])/g, "$1");
+        const escapedParameter = parameter.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+        const escapedBranchValue = branchValue.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+        const branch = new RegExp(`(?:^|\\n)([ \\t]*)if\\s+${escapedParameter}\\s*==\\s*['\"]${escapedBranchValue}['\"]\\s*:\\s*([\\s\\S]*?)(?=\\n\\1(?:elif\\b|else\\s*:)|\\n\\1(?:if\\b|def\\b)|$)`, "m").exec(region)?.[2];
+        if (!branch)
+            continue;
+        const value = new RegExp(`['\"]${escapedField}['\"]\\s*:\\s*([^,}\\n]+)`).exec(branch)?.[1];
+        if (!value)
+            continue;
+        const observed = observeLiteralToken(value.trim(), input.field, input.constants);
+        if (observed)
+            return observed;
+    }
+    return undefined;
+}
 function observeDeterministicFunctionFieldOverride(input) {
     const region = scenarioFunctionRegion(input.source, input.tpId);
     if (!region)
@@ -1507,7 +1634,10 @@ export async function assessBackendScenarioParamConsistency(input) {
                     constants,
                 })
                 : undefined;
-            const observed = functionFieldOverride ?? helperFieldObserved ?? observeParamFeatures(block, inferred.field, constants, parameterNames);
+            const branchFieldObserved = source && inferred.field
+                ? observeBranchPayloadField({ source, tpId, block, parameterNames, field: inferred.field, constants })
+                : undefined;
+            const observed = functionFieldOverride ?? helperFieldObserved ?? branchFieldObserved ?? observeParamFeatures(block, inferred.field, constants, parameterNames);
             // Request-level / health checks often have no pytest.param payload row,
             // or only a TP-id label positional (no field value).
             const requestLevelNoParam = Boolean(source) &&
@@ -1720,6 +1850,12 @@ export function deterministicRewriteScenarioParam(input) {
             }
             valueLiteral = `"x" * ${bound + 1}`;
             break;
+        case "max-1":
+            if (bound === undefined) {
+                return { ok: false, source: input.source, detail: "missing bound for max-1" };
+            }
+            valueLiteral = `"x" * ${Math.max(0, bound - 1)}`;
+            break;
         case "min-1":
             if (bound === undefined) {
                 return { ok: false, source: input.source, detail: "missing bound for min-1" };

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

@@ -43,6 +43,67 @@ function splitCells(raw) {
         .map((cell) => cell.trim())
         .filter((cell, index, cells) => !(cell === "" && (index === 0 || index === cells.length - 1)));
 }
+function isExactSlotInventory(extras, partitionId) {
+    const tokens = extras
+        .join(";")
+        .split(/[;,，；]/)
+        .map((token) => token.trim().replace(/`/g, ""))
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0)
+        return false;
+    const prefix = `TP-${partitionId.trim().toUpperCase()}-`;
+    return tokens.every((token) => /^TP-[A-Z0-9-]+$/i.test(token) &&
+        (token.toUpperCase().startsWith(prefix) || token.toUpperCase().startsWith("TP-SP-")));
+}
+function trimExactSlotInventoryCells(cells) {
+    if (cells.length <= 7)
+        return { cells, trimmed: false };
+    const partitionId = cells[0] ?? "";
+    if (!isExactSlotInventory(cells.slice(7), partitionId)) {
+        return { cells, trimmed: false };
+    }
+    return { cells: cells.slice(0, 7), trimmed: true };
+}
+export function canonicalizeScenarioPartitionTable(markdown) {
+    const lines = markdown.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const headingIndex = lines.findIndex((line) => PARTITION_HEADING.test(line.trim()));
+    if (headingIndex === -1) {
+        return { markdown: lines.join("\n"), changed: false, trimmedRows: 0 };
+    }
+    let headerIndex = -1;
+    let sectionEnd = lines.length;
+    for (let i = headingIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i].trim()) && !PARTITION_HEADING.test(lines[i].trim())) {
+            sectionEnd = i;
+            break;
+        }
+        if (PARTITION_TABLE_HEADER.test(lines[i])) {
+            headerIndex = i;
+        }
+    }
+    if (headerIndex === -1) {
+        return { markdown: lines.join("\n"), changed: false, trimmedRows: 0 };
+    }
+    let trimmedRows = 0;
+    for (let i = headerIndex + 2; i < sectionEnd; i++) {
+        const line = lines[i];
+        if (!TABLE_ROW.test(line)) {
+            if (/^##\s+/.test(line) || /^#\s+/.test(line))
+                break;
+            continue;
+        }
+        const { cells, trimmed } = trimExactSlotInventoryCells(splitCells(line));
+        if (!trimmed)
+            continue;
+        lines[i] = `| ${cells.join(" | ")} |`;
+        trimmedRows += 1;
+    }
+    return {
+        markdown: lines.join("\n"),
+        changed: trimmedRows > 0,
+        trimmedRows,
+    };
+}
 /**
  * Parse the `## Scenario Partitions` section of the README into declared
  * partitions. Returns { partitions, issues }; issues are fail-closed parse
@@ -77,7 +138,7 @@ export function parseScenarioPartitions(readmeMarkdown) {
                 break;
             continue;
         }
-        const cells = splitCells(line);
+        const { cells } = trimExactSlotInventoryCells(splitCells(line));
         if (cells.length !== 7) {
             issues.push(`MISSING_PARTITION: row has ${cells.length} cells, expected 7: ${line.trim()}`);
             continue;

package/dist/workflows/dag/backend-test-writer-completeness.js

@@ -369,8 +369,6 @@ function pythonParseable(source) {
     const normalized = source.replace(/\r\n/g, "\n");
     if (!normalized.trim())
         return false;
-    if (/^\s*(?:def|class|import|from)\b/m.test(normalized) === false)
-        return false;
     const structural = pythonStructureOutsideStrings(normalized);
     if (!structural.stringsClosed)
         return false;
@@ -387,7 +385,13 @@ function pythonParseable(source) {
         return false;
     if (openBraces !== closeBraces)
         return false;
-    return true;
+    // Business modules still need a statement. Evidence-only mapped scripts may
+    // be a closed module docstring + Case-ID with no `def test_` (R10 health).
+    if (/^\s*(?:def|class|import|from|__all__\s*=)/m.test(normalized))
+        return true;
+    return (/^\s*(?:'''|""")/.test(normalized) &&
+        /\bCase-ID\s*:/i.test(normalized) &&
+        !/^\s*(?:async\s+)?def\s+test_/m.test(normalized));
 }
 /**
  * Forbidden generated shared helper/factory namespaces for the self-contained

package/dist/workflows/dag/frontend-recovery-plan.js

@@ -26,7 +26,8 @@ export function deriveFrontendRecoveryFailureSource(result) {
  * Compute the frontend candidate-continuation reset partition:
  * - `frontend-plan-pi` failure → reset plan + design-review + policy/admission (+ descendants);
  * - `frontend-design-policy-shell` failure → reset policy/admission (+ descendants);
- * - admission/design-review failure → reset writer admission (+ descendants);
+ * - design-review rejection → reset plan + design review + admission (+ descendants);
+ * - other admission failures → reset writer admission (+ descendants);
  *
  * Everything upstream of the failure source is imported as verified parent facts.
  */

package/dist/workflows/dag/frontend-recovery-run.js

@@ -275,7 +275,35 @@ async function casUpdateFrontendRecoveryState(parentRunDir, expectedRevision, de
 async function materializeChildStaging(input) {
     const { cwd, parentRunDir, parentRunId, parentSpec, parentState, recovery, requestId, childRunId, stagingDir, createdAt, } = input;
     await prepareRunDir(stagingDir);
-    await writeJsonVerified(stagingDir, "run.json", parentSpec);
+    // Design-review rejection must be visible to the reset planner. Recovery
+    // children otherwise copy the old spec and only rerun design review, which
+    // deterministically re-rejects the unchanged plan. Bind the parent's typed
+    // findings into the child spec as ordinary rerun feedback.
+    let childSpec = parentSpec;
+    if (recovery.failureSource === "frontend-plan-pi") {
+        try {
+            const { deriveDagRerunFeedback } = await import("./rerun-feedback.js");
+            const taskId = parentSpec.taskContractBinding?.taskId ??
+                parentSpec.sourceBinding?.taskId ??
+                parentRunId;
+            const feedback = await deriveDagRerunFeedback({
+                parentRunId,
+                taskId,
+                runDir: parentRunDir,
+                spec: parentSpec,
+                state: parentState,
+            });
+            if (feedback)
+                childSpec = { ...parentSpec, rerunFeedback: feedback };
+        }
+        catch (error) {
+            // A design rejection cannot be safely retried without its typed
+            // findings. Fail closed instead of deterministically re-running the
+            // unchanged plan and producing another rejection.
+            throw new Error(`frontend recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    await writeJsonVerified(stagingDir, "run.json", childSpec);
     // Phase 5: writer transient partial-write recovery resets the writer subtree
     // (frontend-implement-pi) instead of the candidate producer; everything
     // upstream is imported as verified parent facts.
@@ -300,10 +328,10 @@ async function materializeChildStaging(input) {
             result: admissionRead.result,
         });
     }
-    const { ranks } = topoSortToRanks(parentSpec);
+    const { ranks } = topoSortToRanks(childSpec);
     const resetSet = new Set(plan.resetNodeIds);
     const importedSet = new Set(plan.importedNodeIds);
-    const tasksById = new Map(parentSpec.tasks.map((task) => [task.id, task]));
+    const tasksById = new Map(childSpec.tasks.map((task) => [task.id, task]));
     const nodes = {};
     const importedFacts = [];
     for (const nodeId of plan.importedNodeIds) {
@@ -328,7 +356,7 @@ async function materializeChildStaging(input) {
         }
         nodes[nodeId] = buildPendingNodeRecord(task);
     }
-    for (const task of parentSpec.tasks) {
+    for (const task of childSpec.tasks) {
         if (!resetSet.has(task.id) && !importedSet.has(task.id)) {
             throw new Error(`node ${task.id} missing from frontend recovery plan partition`);
         }
@@ -338,7 +366,7 @@ async function materializeChildStaging(input) {
     const canonicalContract = await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
-        relativePath: resolveCanonicalContractRelPath(parentSpec),
+        relativePath: resolveCanonicalContractRelPath(childSpec),
     });
     const writerAdmissionResult = await copyArtifactVerified({
         parentRunDir,