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

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

@@ -98,16 +98,10 @@ async function listMarkdownCases(workspaceRoot) {
             const allPoints = orderedUnique(body.match(/\bTP-[A-Z0-9-]+\b/g) ?? []);
             const variantLabel = body.match(/(?:Variant Test Points|\u53d8\u4f53\u6d4b\u8bd5\u70b9)\s*[:：]\s*([^\n]+)/i)?.[1] ??
                 "";
-            const variantLabelDeclared = variantLabel.trim().length > 0;
-            const variantLabelIsNone = /^(?:none|无|n\/a|not-applicable)\b/i.test(variantLabel.trim());
             const variantFromLabel = orderedUnique((variantLabel.match(/\bTP-[A-Z0-9-]+\b/g) ?? []).filter((item) => item.toUpperCase() !== "NONE"));
-            const variantTestPoints = variantLabelIsNone
-                ? []
-                : variantFromLabel.length > 0
-                    ? variantFromLabel
-                    : variantLabelDeclared
-                        ? []
-                        : allPoints.filter((tp) => /(EMPTY|MISSING|NULL|MIN|MAX|INVALID|WRONG|ENUM|PATTERN|NOMINAL|BOUNDARY)/i.test(tp));
+            const variantTestPoints = variantFromLabel.length > 0
+                ? variantFromLabel
+                : allPoints.filter((tp) => /(EMPTY|MISSING|NULL|MIN|MAX|INVALID|WRONG|ENUM|PATTERN|NOMINAL|BOUNDARY)/i.test(tp));
             const scriptMatch = body.match(/`?(testcase\/[A-Za-z0-9_./-]*test_[A-Za-z0-9_.-]*\.py)`?/i);
             cases.push({
                 caseId,
@@ -121,123 +115,23 @@ async function listMarkdownCases(workspaceRoot) {
     }
     return cases;
 }
-function parseScenarioIntentLine(line) {
-    // Target may contain commas (body.title,body.status). Intent may contain `|` / spaces.
-    // Stop field values only at known trailing keys or end-of-line.
-    const precise = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;]\s*operation\s*=\s*([^;\n]+?)\s*[|;]\s*target\s*=\s*([^;\n]+?)\s*[|;]\s*intent\s*=\s*(.+?)(?:\s*[|;]\s*bound\s*=\s*(\d+))?(?:\s*[|;]\s*example\s*=\s*([^;\n]+))?(?:\s*[|;]\s*expectedCode\s*=\s*[^;\n]+)?\s*$/i.exec(line.trim());
-    if (precise) {
-        return {
-            tpId: precise[1],
-            rawIntent: (precise[4] ?? "unknown").trim(),
-            target: precise[3]?.trim(),
-            bound: precise[5] ? Number(precise[5]) : undefined,
-            example: precise[6]?.trim(),
-            legacy: false,
-        };
-    }
-    const legacy = /场景意图\s*[:：]\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(line.trim());
-    if (legacy) {
-        return {
-            rawIntent: (legacy[1] ?? "unknown").trim(),
-            field: legacy[2],
-            bound: legacy[3] ? Number(legacy[3]) : undefined,
-            example: legacy[4]?.trim(),
-            legacy: true,
-        };
-    }
-    return undefined;
-}
-function resolveScenarioIntentField(target, field) {
-    if (field)
-        return field;
-    if (!target || target === "request")
-        return undefined;
-    const bodyTargets = target
-        .split(/\s*,\s*/)
-        .map((item) => item.trim())
-        .filter((item) => /^(?:body|json|payload)\./i.test(item));
-    const preferred = bodyTargets.find((item) => /\.status$/i.test(item)) ??
-        bodyTargets[0] ??
-        target.split(/\s*,\s*/)[0];
-    return preferred?.split(".").at(-1);
-}
-function resolveCustomLiteralIntent(rawIntent, field) {
-    const lower = rawIntent.toLowerCase();
-    if (!lower.startsWith("custom-literal:")) {
-        return CLOSED_SET.has(lower) ? lower : "unknown";
-    }
-    // Preserve literal case: enum values such as ACTIVE must not be lowercased.
-    const prefixLength = rawIntent.toLowerCase().startsWith("custom-literal:")
-        ? rawIntent.indexOf(":") + 1
-        : "custom-literal:".length;
-    const payload = rawIntent.slice(prefixLength);
-    if (!payload.includes("|") && !payload.includes(",")) {
-        return `custom-literal:${payload}`;
-    }
-    const parts = payload.split(/\s*[|,]\s*/).map((item) => item.trim()).filter(Boolean);
-    if (field) {
-        const byField = parts.find((part) => part.toLowerCase().startsWith(`${field.toLowerCase()}=`));
-        if (byField) {
-            return `custom-literal:${byField.slice(field.length + 1)}`;
-        }
-        if (/^status$/i.test(field)) {
-            const enumLike = parts.find((part) => /^(?:ACTIVE|ARCHIVED|INACTIVE|DISABLED|ENABLED)$/i.test(part));
-            if (enumLike)
-                return `custom-literal:${enumLike}`;
-        }
-        if (/^title$/i.test(field)) {
-            const titleLike = parts.find((part) => !/^(?:ACTIVE|ARCHIVED|INACTIVE|DISABLED|ENABLED)$/i.test(part));
-            if (titleLike)
-                return `custom-literal:${titleLike}`;
-        }
-    }
-    return parts.length === 1
-        ? `custom-literal:${parts[0]}`
-        : "unknown";
-}
 export function inferScenarioParamIntent(input) {
     const { tpId, caseBody } = input;
-    const intentLines = caseBody
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => /场景意图\s*[:：]/.test(line));
-    const parsedLines = intentLines
-        .map((line) => parseScenarioIntentLine(line))
-        .filter((item) => Boolean(item));
-    const preciseForTp = parsedLines.find((item) => item.tpId && item.tpId.toUpperCase() === tpId.toUpperCase());
-    const legacyLine = parsedLines.find((item) => item.legacy);
-    const fallbackLine = new RegExp(`${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,200}?intent\\s*[=:]\\s*([^|;,\uff0c\\n]+)`, "i").exec(caseBody);
-    const machine = preciseForTp ??
-        (legacyLine && parsedLines.filter((item) => !item.legacy).length === 0 ? legacyLine : undefined) ??
-        (fallbackLine
-            ? {
-                rawIntent: fallbackLine[1] ?? "unknown",
-                legacy: true,
-            }
-            : undefined);
-    if (machine) {
-        const field = resolveScenarioIntentField(machine.target, machine.field);
-        const rawIntent = machine.rawIntent.trim();
-        const example = machine.example;
-        const lower = rawIntent.toLowerCase();
-        const normalizedIntent = lower === "nominal-operation" ? "nominal" : lower;
-        const dataSection = sectionBody(caseBody, ["测试数据", "Test Data", "操作步骤", "Steps"]);
-        const fieldScopedBound = field
-            ? new RegExp(`${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,80}?(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})`, "i").exec(`${caseBody}\n${dataSection}`) ??
-                new RegExp(`(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})[^\\n]{0,80}?${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i").exec(`${caseBody}\n${dataSection}`)
-            : undefined;
-        const boundFromBody = fieldScopedBound ??
-            /(?:maxLength|max(?:imum)?|上限|最大长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`) ??
-            /(?:minLength|min(?:imum)?|下限|最小长度)\s*[=:：]?\s*(\d{1,4})/i.exec(`${caseBody}\n${dataSection}`);
-        const bound = machine.bound && machine.bound > 0
-            ? machine.bound
-            : boundFromBody
-                ? Number(boundFromBody[1])
-                : machine.bound;
-        if (rawIntent.toLowerCase().startsWith("custom-literal:")) {
-            const intent = resolveCustomLiteralIntent(rawIntent, field);
+    const preciseLine = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;,，]\s*operation\s*=\s*([^|;,，\n]+)\s*[|;,，]\s*target\s*=\s*([A-Za-z0-9_.-]+)\s*[|;,，]\s*intent\s*=\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(caseBody);
+    const legacyLine = /场景意图\s*[:：]\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(caseBody);
+    const fallbackLine = new RegExp(`${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,160}?intent\\s*[=:]\\s*([a-z0-9+._:-]+)`, "i").exec(caseBody);
+    const machineLine = preciseLine ?? legacyLine ?? fallbackLine;
+    if (machineLine) {
+        const rawIntent = (preciseLine ? preciseLine[4] : machineLine[1] ?? "unknown").toLowerCase();
+        const target = preciseLine?.[3];
+        const field = target && target !== "request" ? target.split(".").at(-1) : legacyLine?.[2];
+        const boundRaw = preciseLine?.[5] ?? legacyLine?.[3];
+        const example = (preciseLine?.[6] ?? legacyLine?.[4])?.trim();
+        const bound = boundRaw ? Number(boundRaw) : undefined;
+        const normalizedIntent = rawIntent === "nominal-operation" ? "nominal" : rawIntent;
+        if (normalizedIntent.startsWith("custom-literal:")) {
             return {
-                intent,
+                intent: normalizedIntent,
                 field,
                 bound,
                 example,
@@ -281,13 +175,7 @@ export function inferScenarioParamIntent(input) {
         ? fieldFromTp.charAt(0).toLowerCase() + fieldFromTp.slice(1)
         : undefined;
     const dataSection = sectionBody(caseBody, ["测试数据", "Test Data", "操作步骤", "Steps"]);
-    const fieldScopedBound = field
-        ? new RegExp(`${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,80}?(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})`, "i").exec(`${caseBody}\n${dataSection}`) ??
-            new RegExp(`(?:maxLength|max(?:imum)?|上限|最大长度)\\s*[=:：]?\\s*(\\d{1,4})[^\\n]{0,80}?${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "i").exec(`${caseBody}\n${dataSection}`)
-        : undefined;
-    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 boundMatch = /(?: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 exampleMatch = /(?:反例|invalid example|example)\s*[=:：]\s*[`"]?([^`"\n]+)[`"]?/i.exec(caseBody);
     const example = exampleMatch?.[1]?.trim();
@@ -360,27 +248,18 @@ export function observeParamFeatures(block, field) {
     if (/\bFaker\b|\bfake\b|\brandom\b|\buuid4\b|\bfactory\b/i.test(block)) {
         return { kind: "call", text: "dynamic-or-faker" };
     }
-    // Prefer dict-like payload extraction when a real object literal is present.
-    // Writers often build the payload in the test body and only pass scalar intent
-    // values in pytest.param; in that case fall through to positional observation.
+    // Prefer dict-like payload extraction.
     const dictMatch = /\{\s*([\s\S]*?)\s*\}/.exec(block) ??
         /(?:payload|body|data|json)\s*=\s*(\{[\s\S]*?\})/.exec(block);
-    const dictText = dictMatch?.[0] ?? dictMatch?.[1] ?? "";
-    const fieldPattern = field
-        ? new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:`)
-        : undefined;
-    const dictHasField = Boolean(fieldPattern && fieldPattern.test(dictText));
-    const dictLooksLikePayload = Boolean(dictMatch) &&
-        (/["'][A-Za-z_][A-Za-z0-9_]*["']\s*:/.test(dictText) ||
-            /(?:payload|body|data|json)\s*=/.test(block));
-    if (dictLooksLikePayload && !field) {
-        return { kind: "dict", text: dictText.replace(/\s+/g, " ").slice(0, 160) };
+    if (dictMatch && !field) {
+        return { kind: "dict", text: (dictMatch[0] ?? dictMatch[1] ?? "{}").replace(/\s+/g, " ").slice(0, 160) };
     }
-    if (dictLooksLikePayload && field) {
-        if (!dictHasField) {
+    if (dictMatch && field) {
+        const dict = dictMatch[0] ?? dictMatch[1] ?? "";
+        const fieldPattern = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:`);
+        if (!fieldPattern.test(dict)) {
             return { kind: "missing-key", text: `missing:${field}` };
         }
-        const dict = dictText;
         const valueMatch = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:\\s*([^,}\\n]+)`).exec(dict);
         const raw = valueMatch?.[1]?.trim() ?? "";
         if (raw === "None" || raw === "null") {
@@ -389,19 +268,6 @@ export function observeParamFeatures(block, field) {
         if (raw === '""' || raw === "''") {
             return { kind: "empty-string", text: '""', length: 0, literal: "" };
         }
-        const repeatedValue = /^(["'])([^"'\\])\1\s*\*\s*(\d{1,5})$/.exec(raw);
-        if (repeatedValue) {
-            const ch = repeatedValue[2] ?? "x";
-            const length = Number(repeatedValue[3] ?? "0");
-            const value = ch.repeat(Math.max(0, length));
-            return {
-                kind: length === 0 ? "empty-string" : "string",
-                text: JSON.stringify(value),
-                length,
-                hasUppercase: /[A-Z]/.test(value),
-                literal: value,
-            };
-        }
         const str = /^["']([\s\S]*)["']$/.exec(raw);
         if (str) {
             const value = str[1] ?? "";
@@ -430,83 +296,31 @@ export function observeParamFeatures(block, field) {
         }
         return { kind: "unknown", text: raw || compact.slice(0, 120) };
     }
-    // Repeated string literal: "a" * 100 / 'x'*101
-    const repeated = /pytest\.param\s*\(\s*(["'])([^"'\\])\1\s*\*\s*(\d{1,5})/.exec(block) ??
-        /(["'])([^"'\\])\1\s*\*\s*(\d{1,5})/.exec(block);
-    if (repeated && (!field || !/\{/.test(block))) {
-        const ch = repeated[2] ?? "x";
-        const length = Number(repeated[3] ?? "0");
-        const value = ch.repeat(Math.max(0, length));
-        return {
-            kind: length === 0 ? "empty-string" : "string",
-            text: JSON.stringify(value),
-            length,
-            hasUppercase: /[A-Z]/.test(value),
-            literal: value,
-        };
-    }
-    // Positional args: skip a leading TP-id label when writers emit
-    // pytest.param("TP-...", actual_value, id="TP-...").
-    const paramOpen = /pytest\.param\s*\(/.exec(block);
-    if (paramOpen) {
-        const afterOpen = block.slice((paramOpen.index ?? 0) + paramOpen[0].length);
-        const positionalLiterals = [];
-        const literalRe = /\s*(None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*(?:,|$)/g;
-        let match;
-        while ((match = literalRe.exec(afterOpen)) !== null) {
-            // Stop once keyword args begin (id=/marks=) after a comma segment without a pure literal.
-            const between = afterOpen.slice(0, match.index);
-            if (/(?:^|,)\s*(?:id|marks)\s*=/.test(between + match[0]))
-                break;
-            positionalLiterals.push(match[1]);
-            if (positionalLiterals.length >= 4)
-                break;
+    // Positional first arg string/None.
+    const firstArg = /pytest\.param\s*\(\s*(None|True|False|-?\d+(?:\.\d+)?|"""[\s\S]*?"""|'''[\s\S]*?'''|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')/.exec(block);
+    if (firstArg) {
+        const raw = firstArg[1];
+        if (raw === "None")
+            return { kind: "none", text: "None", literal: "None" };
+        if (raw === '""' || raw === "''") {
+            return { kind: "empty-string", text: '""', length: 0, literal: "" };
         }
-        const idMatch = /\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/i.exec(block);
-        const idTp = idMatch?.[1]?.toUpperCase();
-        const candidates = positionalLiterals.filter((raw) => {
-            const str = /^["']([\s\S]*)["']$/.exec(raw) ?? /^("""|''')([\s\S]*)\1$/.exec(raw);
-            if (!str)
-                return true;
+        const str = /^["']([\s\S]*)["']$/.exec(raw) ?? /^("""|''')([\s\S]*)\1$/.exec(raw);
+        if (str) {
             const value = (str[2] ?? str[1] ?? "").replace(/^["']|["']$/g, "");
-            // Drop pure TP label positionals that only echo the param id.
-            if (/^TP-[A-Z0-9-]+$/i.test(value) && (!idTp || value.toUpperCase() === idTp)) {
-                return false;
-            }
-            return true;
-        });
-        const raw = candidates[0] ?? positionalLiterals[0];
-        if (raw) {
-            if (raw === "None")
-                return { kind: "none", text: "None", literal: "None" };
-            if (raw === '""' || raw === "''") {
-                return { kind: "empty-string", text: '""', length: 0, literal: "" };
-            }
-            const str = /^["']([\s\S]*)["']$/.exec(raw) ?? /^("""|''')([\s\S]*)\1$/.exec(raw);
-            if (str) {
-                const value = (str[2] ?? str[1] ?? "").replace(/^["']|["']$/g, "");
-                return {
-                    kind: value.length === 0
-                        ? "empty-string"
-                        : "string",
-                    text: JSON.stringify(value),
-                    length: value.length,
-                    hasUppercase: /[A-Z]/.test(value),
-                    literal: value,
-                };
-            }
-            if (/^-?\d+(?:\.\d+)?$/.test(raw)) {
-                return { kind: "number", text: raw, literal: raw };
-            }
-            if (raw === "True" || raw === "False") {
-                return { kind: "boolean", text: raw, literal: raw };
-            }
-            return { kind: "unknown", text: raw };
+            return {
+                kind: "string",
+                text: JSON.stringify(value),
+                length: value.length,
+                hasUppercase: /[A-Z]/.test(value),
+                literal: value,
+            };
         }
+        return { kind: "unknown", text: raw };
     }
     return { kind: "unknown", text: compact.slice(0, 160) };
 }
-function compareIntent(intent, observed, bound, example, field) {
+function compareIntent(intent, observed, bound, example) {
     if (intent === "unknown")
         return "UNDETERMINED";
     if (observed.kind === "call" || observed.kind === "name") {
@@ -515,10 +329,7 @@ function compareIntent(intent, observed, bound, example, field) {
     switch (intent) {
         case "empty":
             return observed.kind === "empty-string" ||
-                (observed.kind === "string" &&
-                    (observed.length === 0 ||
-                        (typeof observed.literal === "string" &&
-                            /^\s+$/.test(observed.literal))))
+                (observed.kind === "string" && observed.length === 0)
                 ? "MATCH"
                 : observed.kind === "unknown"
                     ? "UNDETERMINED"
@@ -536,39 +347,45 @@ function compareIntent(intent, observed, bound, example, field) {
                     ? "UNDETERMINED"
                     : "MISMATCH";
         case "max":
-            if (bound === undefined)
-                return "UNDETERMINED";
-            if (observed.kind === "string" && observed.length === bound)
-                return "MATCH";
-            // Writers may pass the exact length as a numeric positional instead of a repeated string.
-            if (observed.kind === "number" && Number(observed.literal) === bound)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "UNDETERMINED";
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === bound
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
         case "max+1":
-            if (bound === undefined)
-                return "UNDETERMINED";
-            if (observed.kind === "string" && observed.length === bound + 1)
-                return "MATCH";
-            if (observed.kind === "number" && Number(observed.literal) === bound + 1)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "UNDETERMINED";
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === bound + 1
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
         case "min":
-            if (bound === undefined)
-                return "UNDETERMINED";
-            if (observed.kind === "string" && observed.length === bound)
-                return "MATCH";
-            if (observed.kind === "number" && Number(observed.literal) === bound)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "UNDETERMINED";
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === bound
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
         case "min-1":
-            if (bound === undefined)
-                return "UNDETERMINED";
-            const expectedMin1 = Math.max(0, bound - 1);
-            if (observed.kind === "string" && observed.length === expectedMin1)
-                return "MATCH";
-            if (observed.kind === "number" && Number(observed.literal) === expectedMin1)
-                return "MATCH";
-            return observed.kind === "string" || observed.kind === "number" ? "MISMATCH" : "UNDETERMINED";
+            return bound !== undefined &&
+                observed.kind === "string" &&
+                observed.length === Math.max(0, bound - 1)
+                ? "MATCH"
+                : bound === undefined
+                    ? "UNDETERMINED"
+                    : observed.kind === "string"
+                        ? "MISMATCH"
+                        : "UNDETERMINED";
         case "pattern-invalid":
             if (observed.kind === "string" && example !== undefined) {
                 return observed.literal === example ? "MATCH" : "MISMATCH";
@@ -588,10 +405,6 @@ function compareIntent(intent, observed, bound, example, field) {
                 ? "UNDETERMINED"
                 : "UNDETERMINED";
         case "nominal":
-            // Request-level nominal (no body field) may legitimately pass None/empty query filters.
-            if (!field && (observed.kind === "none" || observed.kind === "missing-key")) {
-                return "MATCH";
-            }
             return observed.kind === "string" ||
                 observed.kind === "number" ||
                 observed.kind === "boolean" ||
@@ -699,7 +512,7 @@ export async function assessBackendScenarioParamConsistency(input) {
             const observed = observeParamFeatures(block, inferred.field);
             const status = !source || fallbackSourced
                 ? "UNDETERMINED"
-                : compareIntent(inferred.intent, observed, inferred.bound, inferred.example, inferred.field);
+                : compareIntent(inferred.intent, observed, inferred.bound, inferred.example);
             const repairability = repairabilityFor(status, inferred.intent, observed, inferred.example);
             entries.push({
                 caseId: testCase.caseId,

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

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
-import { BACKEND_TEST_MAX_MODULE_COUNT, isOpaqueHashBackendTestModuleStem, isPriorityOnlyBackendTestModuleStem, } from "./backend-test-module-stem.js";
+import { isPriorityOnlyBackendTestModuleStem } from "./backend-test-module-stem.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -103,8 +103,6 @@ function moduleStemInvalidReason(raw) {
     const stem = normalizeBackendTestModuleStem(raw);
     if (isPriorityOnlyBackendTestModuleStem(stem))
         return "priority-only-module-stem";
-    if (isOpaqueHashBackendTestModuleStem(stem))
-        return "opaque-hash-module-stem";
     if (stem.toLowerCase() === "readme")
         return "reserved-module-stem";
     if (!/^[a-z][a-z0-9_]*$/.test(stem))
@@ -116,40 +114,28 @@ function moduleStemInvalidReason(raw) {
 function looksLikeValidModuleStem(raw) {
     return moduleStemInvalidReason(raw) === undefined;
 }
-function extractCanonicalModuleIndexSection(readme) {
-    const lines = readme
-        .replaceAll("\r\n", "\n")
-        .replaceAll("\r", "\n")
-        .split("\n");
-    const headings = lines.flatMap((line, index) => line.trim() === "## Module Index" ? [index] : []);
-    if (headings.length === 0) {
-        return { section: "", structureIssues: ["missing-module-index"] };
-    }
-    if (headings.length > 1) {
-        return { section: "", structureIssues: ["duplicate-module-index"] };
-    }
-    const start = headings[0] + 1;
-    const relativeEnd = lines.slice(start).findIndex((line) => /^##\s+\S/.test(line.trim()));
-    const end = relativeEnd < 0 ? lines.length : start + relativeEnd;
-    return { section: lines.slice(start, end).join("\n"), structureIssues: [] };
-}
-/** Inspect only candidates inside the unique exact `## Module Index` section. */
+/** Inspect only authoritative README module-index candidates. */
 export function inspectModuleStemsFromReadme(readme) {
-    const extracted = extractCanonicalModuleIndexSection(readme);
     const candidates = [];
-    const tableRowLines = extracted.section.split("\n").filter((line) => line.includes("|"));
+    const tableRowLines = readme
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n")
+        .filter((line) => line.includes("|"));
     for (const line of tableRowLines) {
         for (const match of line.matchAll(/`?testcase\/md\/([A-Za-z0-9_.-]+)\.md`?/g)) {
             candidates.push(match[1]);
         }
         for (const match of line.matchAll(/\|\s*`?([A-Za-z0-9_.-]+)`?\s*\|\s*`?testcase\/test_/g)) {
-            const raw = match[1];
-            if (looksLikeValidModuleStem(raw) || moduleStemInvalidReason(raw) !== "invalid-syntax") {
-                candidates.push(raw);
+            // This compatibility shape can also capture a numeric count column.
+            // Keep valid stems and the priority-only defect we diagnose, while
+            // ignoring non-stem incidental cells such as `1`.
+            if (looksLikeValidModuleStem(match[1]) || isPriorityOnlyBackendTestModuleStem(match[1])) {
+                candidates.push(match[1]);
             }
         }
     }
-    for (const match of extracted.section.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
+    for (const match of readme.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
         candidates.push(match[1]);
     }
     const uniqueCandidates = orderedUnique(candidates);
@@ -159,18 +145,12 @@ export function inspectModuleStemsFromReadme(readme) {
             ? [{ raw, normalized: normalizeBackendTestModuleStem(raw), reasonCode }]
             : [];
     });
-    const validStems = orderedUnique(uniqueCandidates
-        .filter(looksLikeValidModuleStem)
-        .map((stem) => normalizeBackendTestModuleStem(stem)));
-    const structureIssues = [...extracted.structureIssues];
-    if (validStems.length > BACKEND_TEST_MAX_MODULE_COUNT) {
-        structureIssues.push(`excessive-module-count: ${validStems.length} > ${BACKEND_TEST_MAX_MODULE_COUNT}`);
-    }
     return {
         candidates: uniqueCandidates,
-        validStems,
+        validStems: orderedUnique(uniqueCandidates
+            .filter(looksLikeValidModuleStem)
+            .map((stem) => normalizeBackendTestModuleStem(stem))),
         invalid,
-        structureIssues,
     };
 }
 /**
@@ -937,17 +917,6 @@ export async function assessBackendTestMdPlanCompleteness(workspaceRoot) {
         // are produced by map_agent children and are NOT required here.
         const stemInspection = inspectModuleStemsFromReadme(readme);
         const indexedStems = stemInspection.validStems;
-        for (const structureIssue of stemInspection.structureIssues) {
-            if (!brokenPaths.includes("testcase/md/README.md")) {
-                brokenPaths.push("testcase/md/README.md");
-            }
-            issues.push({
-                code: "T5",
-                path: "testcase/md/README.md",
-                detail: structureIssue,
-                recoverable: true,
-            });
-        }
         for (const invalid of stemInspection.invalid) {
             if (!brokenPaths.includes("testcase/md/README.md")) {
                 brokenPaths.push("testcase/md/README.md");

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -367,26 +367,19 @@ export async function executeDynamicMapExpansion(input) {
         }
     }
     const budgetBlockedIds = new Set(blockedChildren.map((entry) => entry.nodeId));
-    const failOnTokenBudgetExhaustion = input.expansion.failOnTokenBudgetExhaustion === true;
     const failedChildren = tolerateChildFailures
         ? []
         : childNodeIds.filter((nodeId) => {
             const record = input.state.nodes[nodeId];
             if (!record || record.status === "FINISHED")
                 return false;
-            if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record)) {
-                return failOnTokenBudgetExhaustion;
-            }
+            if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record))
+                return false;
             return true;
         });
-    const finishedItemCount = childNodeIds.filter((nodeId) => input.state.nodes[nodeId]?.status === "FINISHED").length;
-    const blockedItemCount = budgetBlockedIds.size;
     const aggregate = {
         workflowNodeId: input.expansion.workflowNodeId,
         itemCount: items.length,
-        expectedItemCount: items.length,
-        finishedItemCount,
-        blockedItemCount,
         children: childNodeIds.map((nodeId, index) => ({
             nodeId,
             item: items[index],
@@ -406,30 +399,21 @@ export async function executeDynamicMapExpansion(input) {
                 ?.reason,
         })),
         tokensUsed: totalTokensUsed,
-        maxTotalTokens: tokenBudget?.maxTotalTokens,
         caseOutcomeNotes: caseOutcomeNotes.length > 0 ? caseOutcomeNotes : undefined,
     };
-    const tokenBudgetFailure = failOnTokenBudgetExhaustion && blockedItemCount > 0;
     return {
-        // With tolerateChildFailures: barrier succeeds and product outcomes live in
-        // case evidence. Backend-test opts into token-budget fail-closed because a
-        // partial generated module set is never a valid downstream input.
-        ok: failedChildren.length === 0 && !tokenBudgetFailure,
+        // With tolerateChildFailures: barrier always succeeds; product outcomes live in
+        // case evidence + result materialization. Without it: real child failures fail-close.
+        ok: failedChildren.length === 0,
         stdout: JSON.stringify(aggregate),
         stderr: caseOutcomeNotes.length > 0
             ? `map children recorded as case outcomes: ${caseOutcomeNotes
                 .map((entry) => `${entry.nodeId}=${entry.status}:${entry.reason}`)
                 .join(", ")}`
-            : tokenBudgetFailure
-                ? `dynamic map token budget exhausted: expected=${items.length} finished=${finishedItemCount} blocked=${blockedItemCount} tokensUsed=${totalTokensUsed} maxTotalTokens=${tokenBudget?.maxTotalTokens ?? "unbounded"}`
-                : failedChildren.length > 0
-                    ? `dynamic map children failed: ${failedChildren.join(", ")}`
-                    : "",
-        failureCategory: tokenBudgetFailure
-            ? "dynamic-expansion-token-budget-exhausted"
             : failedChildren.length > 0
-                ? "dynamic-expansion-child-failed"
-                : "success",
+                ? `dynamic map children failed: ${failedChildren.join(", ")}`
+                : "",
+        failureCategory: failedChildren.length > 0 ? "dynamic-expansion-child-failed" : "success",
         durationMs: Date.now() - started,
     };
 }

package/dist/workflows/dag/failure-category.js

@@ -19,6 +19,9 @@ const RAW_TO_NORMALIZED = {
     success: "success",
     "write-guard": "write-guard",
     timeout: "timeout",
+    // Clean implementer stall with zero writes — still a timeout class for report,
+    // but retryable under WRITER_TRANSPORT_RETRY_POLICY.
+    "writer-clean-timeout": "timeout",
     "missing-api-key": "auth",
     auth: "auth",
     "human-rejected": "human-rejected",