@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.10

package/dist/workflows/dag/backend-test-plan-protocol.js

@@ -0,0 +1,106 @@
+/**
+ * Deterministic backend-test plan protocol helpers.
+ *
+ * English canonical `##` headings remain the parse authority. Known Chinese
+ * aliases are rewritten only as an exact whole-line `##` heading, never as
+ * prose. Partition slot coverage follows Scheme A: Case count may be smaller
+ * than the enum count, but every exact `TP-SP-...` slot must appear as an
+ * independent variant Test Point.
+ */
+export const BACKEND_TEST_PLAN_HEADING_ALIASES = {
+    "模块索引": "Module Index",
+    "覆盖范围": "Coverage Scope",
+    "覆盖矩阵": "Coverage Matrix",
+    "场景分区": "Scenario Partitions",
+};
+export const BACKEND_TEST_SCENARIO_PARTITION_SLOTS_SCHEMA_ID = "backend-test-scenario-partition-slots-v1";
+const CANONICAL_HEADING_LINE = /^##\s+(Module Index|Coverage Scope|Coverage Matrix|Scenario Partitions)\s*$/;
+const ALIAS_HEADING_LINE = /^##\s+(模块索引|覆盖范围|覆盖矩阵|场景分区)\s*$/;
+const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{2,3})\b/;
+const SECTION_HEADING = /^###\s+/;
+const TEST_POINT_RE = /\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
+const VARIANT_LABEL = /变体测试点|Variant Test Points/i;
+const FORBIDDEN_SLOT_ALIASES = new Set(["SINGLE", "MULTIPLE"]);
+export function canonicalizeBackendTestPlanProtocolHeadings(markdown) {
+    const lines = markdown.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const rewrittenHeadings = [];
+    const next = lines.map((line) => {
+        const trimmed = line.trim();
+        const alias = ALIAS_HEADING_LINE.exec(trimmed);
+        if (!alias)
+            return line;
+        const canonical = BACKEND_TEST_PLAN_HEADING_ALIASES[alias[1]];
+        rewrittenHeadings.push(canonical);
+        return `## ${canonical}`;
+    });
+    return {
+        markdown: next.join("\n"),
+        changed: rewrittenHeadings.length > 0,
+        rewrittenHeadings,
+    };
+}
+export function countCanonicalPlanHeading(markdown, heading) {
+    const canonical = canonicalizeBackendTestPlanProtocolHeadings(markdown).markdown;
+    return canonical
+        .split("\n")
+        .filter((line) => line.trim() === `## ${heading}`).length;
+}
+function orderedUnique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function collectSectionTokens(body, headingNeedle) {
+    const lines = body.split("\n");
+    const start = lines.findIndex((line) => line.trim() === `### ${headingNeedle}`);
+    if (start < 0)
+        return [];
+    const tokens = [];
+    for (const line of lines.slice(start + 1)) {
+        if (SECTION_HEADING.test(line) || CASE_HEADING.test(line.trim()))
+            break;
+        tokens.push(...(line.match(TEST_POINT_RE) ?? []));
+    }
+    return tokens;
+}
+function collectLabeledTokens(body, label) {
+    return body
+        .split("\n")
+        .filter((line) => label.test(line))
+        .flatMap((line) => line.match(TEST_POINT_RE) ?? []);
+}
+export function collectMarkdownPartitionSlotCoverage(markdown, requiredVariantSlots) {
+    const declaredTestPoints = [];
+    const variantTestPoints = [];
+    const lines = markdown.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const headingIndexes = lines.flatMap((line, index) => CASE_HEADING.test(line.trim()) ? [index] : []);
+    for (let i = 0; i < headingIndexes.length; i += 1) {
+        const start = headingIndexes[i];
+        const end = headingIndexes[i + 1] ?? lines.length;
+        const body = lines.slice(start, end).join("\n");
+        declaredTestPoints.push(...collectSectionTokens(body, "测试点"));
+        variantTestPoints.push(...collectLabeledTokens(body, VARIANT_LABEL));
+    }
+    const declaredSet = new Set(orderedUnique(declaredTestPoints));
+    const variantSet = new Set(orderedUnique(variantTestPoints));
+    const required = requiredVariantSlots.filter((slotId) => !FORBIDDEN_SLOT_ALIASES.has(slotId));
+    return {
+        declaredTestPoints: orderedUnique(declaredTestPoints),
+        variantTestPoints: orderedUnique(variantTestPoints),
+        missingFromDeclared: required.filter((slotId) => !declaredSet.has(slotId)),
+        missingFromVariant: required.filter((slotId) => !variantSet.has(slotId)),
+    };
+}
+export function isForbiddenPartitionSlotAlias(token) {
+    return FORBIDDEN_SLOT_ALIASES.has(token.trim().toUpperCase());
+}
+export function lookupRequiredVariantSlotsForMarkdownPath(inventory, markdownPath) {
+    if (!inventory)
+        return [];
+    const stem = markdownPath
+        .replace(/\\/g, "/")
+        .replace(/^.*\//, "")
+        .replace(/\.md$/i, "");
+    return inventory.modules.find((item) => item.stem === stem)?.requiredVariantSlots ?? [];
+}
+export function isCanonicalPlanHeadingLine(line) {
+    return CANONICAL_HEADING_LINE.test(line.trim());
+}

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";
@@ -1116,7 +1213,11 @@ function compareIntent(intent, observed, bound, example, field) {
                             ? "UNDETERMINED"
                             : "MISMATCH";
                 }
-                return literal === expected
+                const comparableObserved = observed.kind === "boolean"
+                    ? (observed.literal === "True" ? "true" : observed.literal === "False" ? "false" : literal)
+                    : literal;
+                const comparableExpected = expected === "True" ? "true" : expected === "False" ? "false" : expected;
+                return comparableObserved === comparableExpected
                     ? "MATCH"
                     : observed.kind === "unknown"
                         ? "UNDETERMINED"
@@ -1163,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}`
@@ -1207,6 +1312,12 @@ function boundedScenarioText(value, logicalLength) {
     const suffix = `<truncated length=${logicalLength ?? value.length}>`;
     return `${value.slice(0, Math.max(0, MAX_PERSISTED_SCENARIO_TEXT - suffix.length - 3))}...${suffix}`;
 }
+/** Facts schema forbids negative lengths. Internal helper sentinels stay in-memory only. */
+function persistedObservedLength(length) {
+    return typeof length === "number" && Number.isFinite(length) && length >= 0
+        ? Math.trunc(length)
+        : undefined;
+}
 function localPythonFunctionRegion(source, functionName) {
     const escaped = functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const startMatch = new RegExp(`^def\\s+${escaped}\\s*\\(`, "m").exec(source);
@@ -1365,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)
@@ -1449,11 +1586,12 @@ function scenarioParamDiagnosticValues(intent, observed) {
     const expectedRaw = intent.startsWith("custom-literal:")
         ? intent.slice("custom-literal:".length)
         : intent === "unknown" ? undefined : intent;
+    const persistedLength = persistedObservedLength(observed.length);
     return {
         expectedRaw,
-        observedRaw: boundedScenarioText(observed.text, observed.length),
+        observedRaw: boundedScenarioText(observed.text, persistedLength),
         expectedNormalized: expectedRaw === undefined ? undefined : normalizeCustomLiteralExpected(expectedRaw).slice(0, 512),
-        observedNormalized: observed.literal === undefined ? undefined : boundedScenarioText(normalizeScenarioLiteralText(observed.literal), observed.length),
+        observedNormalized: observed.literal === undefined ? undefined : boundedScenarioText(normalizeScenarioLiteralText(observed.literal), persistedLength),
     };
 }
 export async function assessBackendScenarioParamConsistency(input) {
@@ -1496,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) &&
@@ -1539,8 +1680,8 @@ export async function assessBackendScenarioParamConsistency(input) {
                 tpId,
                 field: inferred.field,
                 intent: inferred.intent,
-                observed: boundedScenarioText(observed.text, observed.length),
-                observedLength: observed.length,
+                observed: boundedScenarioText(observed.text, persistedObservedLength(observed.length)),
+                observedLength: persistedObservedLength(observed.length),
                 status,
                 repairability,
                 reasonCode: status === "MATCH" ? "SCENARIO_PARAM_MATCH" : status === "MISMATCH" ? "SCENARIO_PARAM_MISMATCH" : "SCENARIO_PARAM_UNDETERMINED",
@@ -1709,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;