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

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;

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

@@ -4,7 +4,8 @@ import path from "node:path";
 import { z } from "zod";
 import { BACKEND_TEST_MAX_MODULE_COUNT, isOpaqueHashBackendTestModuleStem, isPriorityOnlyBackendTestModuleStem, } from "./backend-test-module-stem.js";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
-import { inspectBackendTestMarkdownTestPointBindings } from "./backend-test-case-coverage-analysis.js";
+import { canonicalizeBackendTestMarkdownTestPointBindings, inspectBackendTestMarkdownTestPointBindings, } from "./backend-test-case-coverage-analysis.js";
+import { BACKEND_TEST_SCENARIO_PARTITION_SLOTS_SCHEMA_ID, canonicalizeBackendTestPlanProtocolHeadings, collectMarkdownPartitionSlotCoverage, lookupRequiredVariantSlotsForMarkdownPath, } from "./backend-test-plan-protocol.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -47,8 +48,16 @@ const progressSchema = z
         path: z.string().optional(),
         detail: z.string(),
         recoverable: z.boolean(),
+        failureSubreason: z.literal("markdown-test-point-binding-format").optional(),
+        affectedCases: z.array(z.string()).optional(),
+        testPointIds: z.array(z.string()).optional(),
+        canonicalizationEligible: z.boolean().optional(),
+        canonicalizationOutcome: z.enum(["not-attempted", "changed", "already-canonical", "unsafe", "revalidation-failed"]).optional(),
     })
         .strict()),
+    canonicalizationOutcome: z.enum(["not-attempted", "changed", "already-canonical", "unsafe", "revalidation-failed"]).optional(),
+    canonicalizedTestPointCount: z.number().int().min(0).optional(),
+    lightweightRepairEligible: z.boolean().optional(),
 })
     .strict();
 async function exists(filePath) {
@@ -119,10 +128,8 @@ function looksLikeValidModuleStem(raw) {
     return moduleStemInvalidReason(raw) === undefined;
 }
 function extractCanonicalModuleIndexSection(readme) {
-    const lines = readme
-        .replaceAll("\r\n", "\n")
-        .replaceAll("\r", "\n")
-        .split("\n");
+    const canonical = canonicalizeBackendTestPlanProtocolHeadings(readme).markdown;
+    const lines = canonical.split("\n");
     const headings = lines.flatMap((line, index) => line.trim() === "## Module Index" ? [index] : []);
     if (headings.length === 0) {
         return { section: "", structureIssues: ["missing-module-index"] };
@@ -362,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;
@@ -380,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
@@ -511,6 +522,19 @@ export async function loadBackendTestWriterProgressForRetry(runDir, taskId) {
  * child's own target file(s): md children are checked for structural
  * completeness, pytest children for parseability. Sibling modules are ignored.
  */
+async function loadScenarioPartitionSlotInventory(runDir) {
+    if (!runDir)
+        return undefined;
+    try {
+        const raw = JSON.parse(await readFile(path.join(runDir, "contracts", "backend-test-scenario-partition-slots.json"), "utf8"));
+        if (raw?.schemaId !== BACKEND_TEST_SCENARIO_PARTITION_SLOTS_SCHEMA_ID)
+            return undefined;
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function assessBackendTestShardChildCompleteness(input) {
     const role = input.role;
     const targetPaths = input.writeSet
@@ -520,6 +544,12 @@ export async function assessBackendTestShardChildCompleteness(input) {
     const actualPaths = [];
     const missingPaths = [];
     const brokenPaths = [];
+    let canonicalizationOutcome = role === "md-generate" ? "already-canonical" : undefined;
+    let canonicalizedTestPointCount = 0;
+    let lightweightRepairEligible = false;
+    const slotInventory = role === "md-generate"
+        ? await loadScenarioPartitionSlotInventory(input.runDir)
+        : undefined;
     for (const target of targetPaths) {
         // Rendered map-child writeSet entries are concrete (e.g.
         // testcase/md/health.md / testcase/test_orders.py); glob-only entries are
@@ -538,16 +568,65 @@ export async function assessBackendTestShardChildCompleteness(input) {
             continue;
         }
         actualPaths.push(target);
-        const body = await readFile(absolute, "utf8");
+        let body = await readFile(absolute, "utf8");
         if (role === "md-generate") {
+            const beforeBindings = inspectBackendTestMarkdownTestPointBindings(body);
+            const canonicalization = canonicalizeBackendTestMarkdownTestPointBindings(body);
+            if (canonicalization.changed) {
+                await writeFile(absolute, canonicalization.markdown, "utf8");
+                body = canonicalization.markdown;
+                canonicalizationOutcome = "changed";
+                canonicalizedTestPointCount += canonicalization.canonicalizedTestPoints.length;
+            }
+            const afterBindings = inspectBackendTestMarkdownTestPointBindings(body);
+            const unresolved = afterBindings.flatMap((entry) => entry.unclassifiedTestPoints);
+            const bindingCases = afterBindings
+                .filter((entry) => entry.unclassifiedTestPoints.length > 0 || entry.duplicateBindingTestPoints.length > 0)
+                .map((entry) => entry.caseId);
             const structural = moduleStructurallyComplete(body);
+            const requiredSlots = lookupRequiredVariantSlotsForMarkdownPath(slotInventory, target);
+            const slotCoverage = requiredSlots.length > 0
+                ? collectMarkdownPartitionSlotCoverage(body, requiredSlots)
+                : undefined;
+            const missingSlots = orderedUnique([
+                ...(slotCoverage?.missingFromDeclared ?? []),
+                ...(slotCoverage?.missingFromVariant ?? []),
+            ]);
+            if (missingSlots.length > 0) {
+                lightweightRepairEligible = true;
+                if (!brokenPaths.includes(target))
+                    brokenPaths.push(target);
+                issues.push({
+                    code: "T5",
+                    path: target,
+                    detail: `incomplete-partition-slot-set: missing ${missingSlots.join(", ")}; Scheme A requires each exact slot as an independent variant Test Point, not Case count or SINGLE/MULTIPLE aliases`,
+                    recoverable: true,
+                    affectedCases: afterBindings.map((entry) => entry.caseId),
+                    testPointIds: missingSlots,
+                });
+            }
             if (!structural.ok) {
+                lightweightRepairEligible = bindingCases.length > 0;
+                if (bindingCases.length > 0)
+                    canonicalizationOutcome = canonicalization.changed ? "revalidation-failed" : "unsafe";
                 brokenPaths.push(target);
+                const bindingFormatIssue = bindingCases.length > 0;
                 issues.push({
                     code: "T5",
                     path: target,
                     detail: moduleStructuralDetail(structural),
                     recoverable: true,
+                    ...(bindingFormatIssue
+                        ? {
+                            failureSubreason: "markdown-test-point-binding-format",
+                            affectedCases: orderedUnique(bindingCases),
+                            testPointIds: orderedUnique(unresolved),
+                            canonicalizationEligible: canonicalization.canonicalizedTestPoints.length > 0,
+                            canonicalizationOutcome: canonicalization.changed
+                                ? (unresolved.length === 0 ? "changed" : "revalidation-failed")
+                                : (beforeBindings.some((entry) => entry.unclassifiedTestPoints.length > 0) ? "unsafe" : "already-canonical"),
+                        }
+                        : {}),
                 });
             }
         }
@@ -586,6 +665,9 @@ export async function assessBackendTestShardChildCompleteness(input) {
         brokenPaths: orderedUnique(brokenPaths),
         targetPaths: recoverableTargets,
         issues,
+        ...(role === "md-generate"
+            ? { canonicalizationOutcome, canonicalizedTestPointCount, lightweightRepairEligible }
+            : {}),
     };
 }
 export async function assessBackendTestMdWriterCompleteness(workspaceRoot, layout) {
@@ -609,7 +691,7 @@ export async function assessBackendTestMdWriterCompleteness(workspaceRoot, layou
     }
     else {
         actualPaths.push(readmeRel);
-        readme = await readFile(readmePath, "utf8");
+        readme = canonicalizeBackendTestPlanProtocolHeadings(await readFile(readmePath, "utf8")).markdown;
         if (!readme.includes("## Coverage Scope")) {
             brokenPaths.push(readmeRel);
             issues.push({
@@ -853,7 +935,7 @@ export async function writeBackendTestWriterProgressArtifacts(input) {
         "## Issues",
         "",
         ...(input.progress.issues.length
-            ? input.progress.issues.map((issue) => `- [${issue.code}] ${issue.path ?? "(workspace)"}: ${issue.detail}`)
+            ? input.progress.issues.map((issue) => `- [${issue.code}] ${issue.path ?? "(workspace)"}: ${issue.detail}${issue.failureSubreason ? `; failureSubreason=${issue.failureSubreason}; canonicalizationOutcome=${issue.canonicalizationOutcome ?? "not-attempted"}; canonicalizationEligible=${issue.canonicalizationEligible ?? false}; affectedCases=${(issue.affectedCases ?? []).join(",") || "none"}; testPointIds=${(issue.testPointIds ?? []).join(",") || "none"}` : ""}`)
             : ["- None"]),
         "",
         `<!-- sha256:${createHash("sha256").update(JSON.stringify(parsed)).digest("hex")} -->`,
@@ -862,6 +944,16 @@ export async function writeBackendTestWriterProgressArtifacts(input) {
     await writeFile(reportPath, body, "utf8");
     return { factsPath, reportPath };
 }
+export function isBackendTestPytestCollectionRepairOutcomeRecoveryCandidate(task) {
+    return (task.id === "repair-backend-pytest-collection-pi" &&
+        task.executor === "pi" &&
+        task.role === "implementer" &&
+        task.toolProfile === "write" &&
+        task.writePolicy === "exclusive" &&
+        (task.writeSet?.length ?? 0) > 0 &&
+        task.writerOutcomePolicy?.type === "implementation-outcome-v1" &&
+        task.writerOutcomePolicy.requireChangedFiles === true);
+}
 export function isBackendTestCompletenessRetryCandidate(task) {
     if (task.executor !== "pi" || task.role !== "implementer")
         return false;
@@ -933,7 +1025,7 @@ export async function assessBackendTestMdPlanCompleteness(workspaceRoot, layout)
     }
     else {
         actualPaths.push(planReadmeRel);
-        const readme = await readFile(readmePath, "utf8");
+        const readme = canonicalizeBackendTestPlanProtocolHeadings(await readFile(readmePath, "utf8")).markdown;
         if (!readme.includes("## Coverage Scope")) {
             brokenPaths.push(planReadmeRel);
             issues.push({