@tea-agent/loop-agent 0.39.0-beta.12 → 0.39.0-beta.13

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

@@ -20,7 +20,8 @@ const factsSchema = z
         tpId: z.string(),
         field: z.string().optional(),
         intent: z.string(),
-        observed: z.string(),
+        observed: z.string().max(200),
+        observedLength: z.number().int().min(0).optional(),
         status: z.enum(["MATCH", "MISMATCH", "UNDETERMINED"]),
         repairability: z.enum([
             "repairable",
@@ -28,6 +29,12 @@ const factsSchema = z
             "none",
             "undetermined-no-repair",
         ]),
+        reasonCode: z.enum(["SCENARIO_PARAM_MATCH", "SCENARIO_PARAM_MISMATCH", "SCENARIO_PARAM_UNDETERMINED"]),
+        expectedRaw: z.string().max(512).optional(),
+        observedRaw: z.string().max(512),
+        expectedNormalized: z.string().max(512).optional(),
+        observedNormalized: z.string().max(512).optional(),
+        sourceLocation: z.string().max(512).optional(),
         suggestedFix: z.string().optional(),
         scriptPath: z.string().optional(),
         bound: z.number().optional(),
@@ -435,8 +442,16 @@ function isWhitespacePaddedString(value) {
 }
 function normalizeScenarioLiteralText(value) {
     // Writers sometimes emit visible-space placeholders (U+2420), NBSP variants,
-    // or URL-encoded spaces in machine-readable Markdown.
+    // URL-encoded spaces, or explicit Python/JSON whitespace escapes in
+    // machine-readable Markdown. Decode only escapes that resolve to whitespace;
+    // ordinary business characters such as `\\u0041` remain literal and fail closed.
+    const decodeWhitespaceEscape = (token, hex) => {
+        const decoded = String.fromCodePoint(Number.parseInt(hex, 16));
+        return /^\s$/u.test(decoded) || /[   ]/u.test(decoded) ? decoded : token;
+    };
     const normalized = value
+        .replace(/\\u([0-9a-f]{4})/gi, decodeWhitespaceEscape)
+        .replace(/\\x([0-9a-f]{2})/gi, decodeWhitespaceEscape)
         .replace(/␠/g, " ")
         .replace(/ /g, " ")
         .replace(/ /g, " ")
@@ -677,6 +692,50 @@ export function extractPytestParamBlock(source, tpId) {
     }
     return undefined;
 }
+function extractPytestParamTopLevelArgs(block) {
+    if (!block)
+        return [];
+    const open = block.indexOf("(");
+    const close = block.lastIndexOf(")");
+    if (open < 0 || close <= open)
+        return [];
+    const input = block.slice(open + 1, close);
+    const args = [];
+    let start = 0;
+    let depth = 0;
+    let quote = "";
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const ch = input[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote)
+                quote = "";
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "[" || ch === "{" || ch === "(")
+            depth += 1;
+        else if (ch === "]" || ch === "}" || ch === ")")
+            depth -= 1;
+        else if (ch === "," && depth === 0) {
+            args.push(input.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    args.push(input.slice(start).trim());
+    return args.filter((arg) => arg && !/^(?:id|marks)\s*=/.test(arg));
+}
 function extractPytestParamParameterNames(source, tpId) {
     const block = extractPytestParamBlock(source, tpId);
     if (!block)
@@ -688,8 +747,11 @@ function extractPytestParamParameterNames(source, tpId) {
     if (decoratorIndex < 0)
         return [];
     const prefix = source.slice(decoratorIndex, blockIndex);
-    const match = /@pytest\.mark\.parametrize\s*\(\s*["']([^"']+)["']/s.exec(prefix);
-    return match?.[1]?.split(",").map((name) => name.trim()).filter(Boolean) ?? [];
+    const scalar = /@pytest\.mark\.parametrize\s*\(\s*["']([^"']+)["']/s.exec(prefix)?.[1];
+    if (scalar)
+        return scalar.split(",").map((name) => name.trim()).filter(Boolean);
+    const tuple = /@pytest\.mark\.parametrize\s*\(\s*\(\s*((?:["'][^"']+["']\s*,?\s*)+)\)/s.exec(prefix)?.[1];
+    return tuple ? [...tuple.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]).filter(Boolean) : [];
 }
 export function observeParamFeatures(block, field, constants, parameterNames) {
     if (!block)
@@ -749,48 +811,7 @@ export function observeParamFeatures(block, field, constants, parameterNames) {
     }
     // Parse top-level positional args before the legacy token scanner so list
     // cardinality and field/value rows remain statically visible.
-    const topLevelArgs = (() => {
-        const open = block.indexOf("(");
-        const close = block.lastIndexOf(")");
-        if (open < 0 || close <= open)
-            return [];
-        const input = block.slice(open + 1, close);
-        const args = [];
-        let start = 0;
-        let depth = 0;
-        let quote = "";
-        let escaped = false;
-        for (let i = 0; i < input.length; i += 1) {
-            const ch = input[i];
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (ch === "\\") {
-                escaped = true;
-                continue;
-            }
-            if (quote) {
-                if (ch === quote)
-                    quote = "";
-                continue;
-            }
-            if (ch === '"' || ch === "'") {
-                quote = ch;
-                continue;
-            }
-            if (ch === "[" || ch === "{" || ch === "(")
-                depth += 1;
-            else if (ch === "]" || ch === "}" || ch === ")")
-                depth -= 1;
-            else if (ch === "," && depth === 0) {
-                args.push(input.slice(start, i).trim());
-                start = i + 1;
-            }
-        }
-        args.push(input.slice(start).trim());
-        return args.filter((arg) => arg && !/^(?:id|marks)\s*=/.test(arg));
-    })();
+    const topLevelArgs = extractPytestParamTopLevelArgs(block);
     if (topLevelArgs.length > 0) {
         const idTp = /\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/i.exec(block)?.[1]?.toUpperCase();
         const meaningfulArgs = topLevelArgs.filter((arg) => {
@@ -1161,11 +1182,13 @@ function suggestedFixFor(intent, field, bound, example) {
                 : undefined;
         default:
             if (intent.startsWith("custom-literal:")) {
-                const expected = intent.slice("custom-literal:".length);
-                if (isWhitespaceSemanticLiteral(expected)) {
-                    return field ? `set ${field}="   "` : 'set value="   "';
+                const expectedRaw = intent.slice("custom-literal:".length);
+                const expected = normalizeCustomLiteralExpected(expectedRaw);
+                if (isWhitespaceSemanticLiteral(expectedRaw) || isWhitespaceOnlyString(expected)) {
+                    const length = isWhitespaceOnlyString(expected) ? expected.length : 3;
+                    return field ? `set ${field} to ${length} literal spaces` : `set value to ${length} literal spaces`;
                 }
-                if (isWhitespacePaddedSemanticLiteral(expected)) {
+                if (isWhitespacePaddedSemanticLiteral(expectedRaw)) {
                     return field
                         ? `set ${field}="  ${field}-value  "`
                         : 'set value="  value  "';
@@ -1177,6 +1200,200 @@ function suggestedFixFor(intent, field, bound, example) {
             return undefined;
     }
 }
+const MAX_PERSISTED_SCENARIO_TEXT = 192;
+function boundedScenarioText(value, logicalLength) {
+    if (value.length <= MAX_PERSISTED_SCENARIO_TEXT)
+        return value;
+    const suffix = `<truncated length=${logicalLength ?? value.length}>`;
+    return `${value.slice(0, Math.max(0, MAX_PERSISTED_SCENARIO_TEXT - suffix.length - 3))}...${suffix}`;
+}
+function localPythonFunctionRegion(source, functionName) {
+    const escaped = functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const startMatch = new RegExp(`^def\\s+${escaped}\\s*\\(`, "m").exec(source);
+    if (!startMatch || startMatch.index === undefined)
+        return undefined;
+    const start = startMatch.index;
+    const remainder = source.slice(start + startMatch[0].length);
+    const nextTopLevel = /^(?:def|class|@pytest\b|@(?:[A-Za-z_][A-Za-z0-9_.]*))\s*/m.exec(remainder);
+    return source.slice(start, nextTopLevel?.index === undefined ? source.length : start + startMatch[0].length + nextTopLevel.index);
+}
+function splitPythonTopLevelArguments(input) {
+    const args = [];
+    let start = 0;
+    let depth = 0;
+    let quote = "";
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const ch = input[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote)
+                quote = "";
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "[" || ch === "{" || ch === "(")
+            depth += 1;
+        else if (ch === "]" || ch === "}" || ch === ")")
+            depth -= 1;
+        else if (ch === "," && depth === 0) {
+            args.push(input.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    args.push(input.slice(start).trim());
+    return args.filter(Boolean);
+}
+function parseSimplePythonCall(expression) {
+    const call = /^([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*)\)$/.exec(expression.trim());
+    if (!call)
+        return undefined;
+    const positional = [];
+    const keywords = new Map();
+    for (const argument of splitPythonTopLevelArguments(call[2] ?? "")) {
+        const keyword = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]+)$/.exec(argument);
+        if (keyword) {
+            if (keywords.has(keyword[1]))
+                return undefined;
+            keywords.set(keyword[1], keyword[2].trim());
+        }
+        else {
+            if (keywords.size > 0 || /^\*{1,2}/.test(argument))
+                return undefined;
+            positional.push(argument);
+        }
+    }
+    return { name: call[1], positional, keywords };
+}
+function safeSameModuleDictHelper(source, helperName) {
+    if (!helperName.startsWith("_"))
+        return undefined;
+    const region = localPythonFunctionRegion(source, helperName);
+    if (!region)
+        return undefined;
+    const functionBody = region.slice(region.indexOf(":") + 1);
+    const escapedName = helperName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (new RegExp(`\\b${escapedName}\\s*\\(`).test(functionBody))
+        return undefined;
+    if (/\b(?:Faker|fake|random|randint|uuid4|environ|getenv|requests|httpx|urlopen|subprocess|Popen|socket|open)\b/i.test(region))
+        return undefined;
+    const signature = new RegExp(`^def\\s+${escapedName}\\s*\\(([\\s\\S]*?)\\)\\s*(?:->[^:]+)?\\s*:`, "m").exec(region);
+    if (!signature)
+        return undefined;
+    const parameters = [];
+    for (const rawParameter of splitPythonTopLevelArguments(signature[1] ?? "")) {
+        if (rawParameter === "*" || rawParameter === "/")
+            continue;
+        if (/^\*{1,2}/.test(rawParameter))
+            return undefined;
+        const parameter = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s*:[^=]+)?(?:\s*=\s*([\s\S]+))?$/.exec(rawParameter);
+        if (!parameter)
+            return undefined;
+        parameters.push({ name: parameter[1], defaultExpression: parameter[2]?.trim() });
+    }
+    const directReturn = /\breturn\s*(\{[\s\S]*?\})/.exec(functionBody)?.[1];
+    const assignment = /\b([A-Za-z_][A-Za-z0-9_]*)\s*(?::[^=\n]+)?=\s*(\{[\s\S]*?\})/.exec(functionBody);
+    const assignedReturn = assignment && new RegExp(`\\breturn\\s+${assignment[1].replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(functionBody)
+        ? assignment[2]
+        : undefined;
+    const dictExpression = directReturn ?? assignedReturn;
+    if (!dictExpression)
+        return undefined;
+    const fieldBindings = new Map();
+    for (const item of splitPythonTopLevelArguments(dictExpression.slice(1, -1))) {
+        const binding = /^(?:["']([^"']+)["'])\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/.exec(item);
+        if (!binding || !parameters.some((parameter) => parameter.name === binding[2]))
+            return undefined;
+        fieldBindings.set(binding[1], binding[2]);
+    }
+    return { parameters, fieldBindings };
+}
+function observeSameModulePayloadHelperField(input) {
+    const payloadIndex = input.parameterNames.findIndex((name) => /^(?:payload|body|data|json)$/i.test(name));
+    if (payloadIndex < 0)
+        return undefined;
+    let expression = extractPytestParamTopLevelArgs(input.block)[payloadIndex]?.trim() ?? "";
+    const wrapper = parseSimplePythonCall(expression);
+    if (wrapper?.name === "_without") {
+        if (wrapper.positional.length !== 2 || wrapper.keywords.size > 0)
+            return undefined;
+        const removed = observeLiteralToken(wrapper.positional[1], input.field, input.constants);
+        if (removed?.kind !== "string" || removed.literal !== input.field)
+            return undefined;
+        expression = wrapper.positional[0];
+        const inner = parseSimplePythonCall(expression);
+        if (!inner || !safeSameModuleDictHelper(input.source, inner.name))
+            return undefined;
+        return { kind: "missing-key", text: `missing:${input.field}` };
+    }
+    const call = parseSimplePythonCall(expression);
+    if (!call)
+        return undefined;
+    const helper = safeSameModuleDictHelper(input.source, call.name);
+    if (!helper)
+        return undefined;
+    const parameterName = helper.fieldBindings.get(input.field);
+    if (!parameterName)
+        return { kind: "missing-key", text: `missing:${input.field}` };
+    const parameterIndex = helper.parameters.findIndex((parameter) => parameter.name === parameterName);
+    if (parameterIndex < 0 || call.positional.length > helper.parameters.length)
+        return undefined;
+    const expressionForField = call.keywords.get(parameterName) ?? call.positional[parameterIndex] ?? helper.parameters[parameterIndex]?.defaultExpression;
+    return expressionForField
+        ? observeLiteralToken(expressionForField, input.field, input.constants)
+        : undefined;
+}
+function hasSafeSameModulePayloadHelper(source, block, parameterNames) {
+    const payloadIndex = parameterNames.findIndex((name) => /^(?:payload|body|data|json)$/i.test(name));
+    if (payloadIndex < 0)
+        return false;
+    const expression = extractPytestParamTopLevelArgs(block)[payloadIndex]?.trim() ?? "";
+    const call = parseSimplePythonCall(expression);
+    if (!call)
+        return false;
+    if (/\b(?:Faker|fake|random|randint|uuid4|environ|getenv|requests|httpx|urlopen|subprocess|Popen|socket|open)\b/i.test(expression))
+        return false;
+    return Boolean(safeSameModuleDictHelper(source, call.name));
+}
+function observeDeterministicFunctionFieldOverride(input) {
+    const region = scenarioFunctionRegion(input.source, input.tpId);
+    if (!region)
+        return undefined;
+    const escapedField = input.field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const assignment = new RegExp(`^([ \\t]*)([A-Za-z_][A-Za-z0-9_]*)\\s*\\[\\s*["']${escapedField}["']\\s*\\]\\s*=\\s*([A-Za-z_][A-Za-z0-9_]*)\\s*$`, "m").exec(region);
+    if (!assignment)
+        return undefined;
+    const indentation = assignment[1]?.length ?? 0;
+    const valueParameter = assignment[3];
+    const valueIndex = input.parameterNames.indexOf(valueParameter);
+    if (valueIndex < 0)
+        return undefined;
+    const beforeAssignment = region.slice(0, assignment.index);
+    const guardMatches = [...beforeAssignment.matchAll(/^([ \\t]*)if\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*$/gm)];
+    const nearestGuard = guardMatches.at(-1);
+    if (nearestGuard && (nearestGuard[1]?.length ?? 0) < indentation) {
+        const guardIndex = input.parameterNames.indexOf(nearestGuard[2]);
+        if (guardIndex < 0)
+            return undefined;
+        const guardExpression = extractPytestParamTopLevelArgs(input.block)[guardIndex]?.trim();
+        if (guardExpression !== "True")
+            return undefined;
+    }
+    const valueExpression = extractPytestParamTopLevelArgs(input.block)[valueIndex]?.trim();
+    return valueExpression
+        ? observeLiteralToken(valueExpression, input.field, input.constants)
+        : undefined;
+}
 function scenarioFunctionRegion(source, tpId) {
     const idIndex = source.indexOf(`id="${tpId}"`) >= 0
         ? source.indexOf(`id="${tpId}"`)
@@ -1202,6 +1419,43 @@ function hasCreateDeleteDerivedJourney(source, tpId) {
         (/\b_create[A-Za-z0-9_]*\s*\(/.test(region) &&
             (/\b_delete[A-Za-z0-9_]*\s*\(/.test(region) || /\.delete\s*\(/.test(region) || /\.request\s*\(\s*["']DELETE["']/i.test(region)));
 }
+function hasConditionalFieldOmission(source, tpId, field, parameterNames) {
+    if (!field)
+        return false;
+    const region = scenarioFunctionRegion(source, tpId);
+    const escapedField = field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const candidateNames = parameterNames.filter((name) => {
+        const normalized = name.toLowerCase();
+        const normalizedField = field.toLowerCase();
+        return normalized === normalizedField || normalized.startsWith(`${normalizedField}_`) || normalized.endsWith(`_${normalizedField}`);
+    });
+    return candidateNames.some((name) => {
+        const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp(`\\{\\s*\\}\\s*if\\s+${escapedName}\\s+is\\s+None\\s+else\\s+\\{[\\s\\S]{0,200}?["']${escapedField}["']\\s*:\\s*${escapedName}\\b`).test(region) ||
+            new RegExp(`\\{[\\s\\S]{0,200}?["']${escapedField}["']\\s*:\\s*${escapedName}\\b[\\s\\S]{0,200}?\\}\\s*if\\s+${escapedName}\\s+is\\s+not\\s+None\\s+else\\s+\\{\\s*\\}`).test(region) ||
+            new RegExp(`if\\s+${escapedName}\\s+is\\s+not\\s+None\\s*:[\\s\\S]{0,200}?["']${escapedField}["']\\s*\\]\\s*=\\s*${escapedName}\\b`).test(region);
+    });
+}
+function scenarioParamSourceLocation(scriptPath, source, tpId) {
+    const block = extractPytestParamBlock(source, tpId);
+    if (!block)
+        return undefined;
+    const index = source.indexOf(block);
+    if (index < 0)
+        return undefined;
+    return `${scriptPath}:${source.slice(0, index).split("\n").length}`;
+}
+function scenarioParamDiagnosticValues(intent, observed) {
+    const expectedRaw = intent.startsWith("custom-literal:")
+        ? intent.slice("custom-literal:".length)
+        : intent === "unknown" ? undefined : intent;
+    return {
+        expectedRaw,
+        observedRaw: boundedScenarioText(observed.text, observed.length),
+        expectedNormalized: expectedRaw === undefined ? undefined : normalizeCustomLiteralExpected(expectedRaw).slice(0, 512),
+        observedNormalized: observed.literal === undefined ? undefined : boundedScenarioText(normalizeScenarioLiteralText(observed.literal), observed.length),
+    };
+}
 export async function assessBackendScenarioParamConsistency(input) {
     const cases = await listMarkdownCases(input.workspaceRoot, input.layout);
     const entries = [];
@@ -1223,7 +1477,26 @@ export async function assessBackendScenarioParamConsistency(input) {
             const constants = source ? collectPythonStringConstants(source) : undefined;
             const block = source ? extractPytestParamBlock(source, tpId) : undefined;
             const parameterNames = source ? extractPytestParamParameterNames(source, tpId) : [];
-            const observed = observeParamFeatures(block, inferred.field, constants, parameterNames);
+            const functionFieldOverride = source && inferred.field
+                ? observeDeterministicFunctionFieldOverride({
+                    source,
+                    tpId,
+                    block,
+                    parameterNames,
+                    field: inferred.field,
+                    constants,
+                })
+                : undefined;
+            const helperFieldObserved = source && inferred.field
+                ? observeSameModulePayloadHelperField({
+                    source,
+                    block,
+                    parameterNames,
+                    field: inferred.field,
+                    constants,
+                })
+                : undefined;
+            const observed = functionFieldOverride ?? helperFieldObserved ?? 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) &&
@@ -1242,9 +1515,17 @@ export async function assessBackendScenarioParamConsistency(input) {
                     hasCreateDeleteDerivedJourney(source, tpId)) ||
                     (/^custom-literal:(?:create-derived(?:-active-id|-id)?|active-existing-derived)$/i.test(inferred.intent) &&
                         hasCreateDerivedJourney(source, tpId)));
+            const conditionalOmissionMatch = Boolean(source) &&
+                inferred.intent === "missing" &&
+                observed.kind === "none" &&
+                hasConditionalFieldOmission(source, tpId, inferred.field, parameterNames);
+            const localPayloadHelperMatch = Boolean(source) &&
+                inferred.intent === "nominal" &&
+                !inferred.field &&
+                hasSafeSameModulePayloadHelper(source, block, parameterNames);
             const status = !source
                 ? "UNDETERMINED"
-                : derivedJourneyMatch
+                : derivedJourneyMatch || conditionalOmissionMatch || localPayloadHelperMatch
                     ? "MATCH"
                     : requestLevelNoParam
                         ? "MATCH"
@@ -1252,14 +1533,19 @@ export async function assessBackendScenarioParamConsistency(input) {
                             ? "UNDETERMINED"
                             : compareIntent(inferred.intent, observed, inferred.bound, inferred.example, inferred.field);
             const repairability = repairabilityFor(status, inferred.intent, observed, inferred.example);
+            const diagnostics = scenarioParamDiagnosticValues(inferred.intent, observed);
             entries.push({
                 caseId: testCase.caseId,
                 tpId,
                 field: inferred.field,
                 intent: inferred.intent,
-                observed: observed.text,
+                observed: boundedScenarioText(observed.text, observed.length),
+                observedLength: observed.length,
                 status,
                 repairability,
+                reasonCode: status === "MATCH" ? "SCENARIO_PARAM_MATCH" : status === "MISMATCH" ? "SCENARIO_PARAM_MISMATCH" : "SCENARIO_PARAM_UNDETERMINED",
+                ...diagnostics,
+                sourceLocation: source ? scenarioParamSourceLocation(testCase.scriptPath, source, tpId) : undefined,
                 suggestedFix: fallbackSourced
                     ? undefined
                     : suggestedFixFor(inferred.intent, inferred.field, inferred.bound, inferred.example),

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

@@ -4,6 +4,7 @@ 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";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -276,6 +277,16 @@ function moduleStructurallyComplete(markdown) {
             reasons: [`missing required sections: [${missing.join(", ")}]`],
         };
     }
+    const bindingReasons = inspectBackendTestMarkdownTestPointBindings(markdown).flatMap((entry) => [
+        ...(entry.unclassifiedTestPoints.length > 0
+            ? [`${entry.caseId} has unclassified Test Points: ${entry.unclassifiedTestPoints.join(", ")}`]
+            : []),
+        ...(entry.duplicateBindingTestPoints.length > 0
+            ? [`${entry.caseId} has duplicate Test Point bindings: ${entry.duplicateBindingTestPoints.join(", ")}`]
+            : []),
+    ]);
+    if (bindingReasons.length > 0)
+        return { ok: false, reasons: bindingReasons };
     return { ok: true, reasons: [] };
 }
 function moduleStructuralDetail(result) {

package/dist/workflows/dag/dag-retry-schema.js

@@ -0,0 +1,138 @@
+import { z } from "zod";
+/**
+ * Leaf module for the retry-policy schema surface: failure-category constants,
+ * the zod retry-policy schema, and the target-template transient retry profile
+ * literal.
+ *
+ * `types.ts` reads `dagRetryPolicySchema` / `TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE`
+ * during its own module initialization, and the retry-policy module transitively
+ * reaches `types.ts` (retry-policy → frontend-recovery-capsule →
+ * frontend-recovery-lineage → frontend-implementation-contract → types). With
+ * these definitions living in retry-policy itself, a run whose entry module is
+ * retry-policy (e.g. test/dag-node-retry.test.ts) evaluates `types.ts` while
+ * retry-policy is still initializing and reads an undefined
+ * `dagRetryPolicySchema`. Keeping this module a leaf (zod is its only import)
+ * makes the cycle resolve order-independently; retry-policy re-exports
+ * everything for source compatibility.
+ */
+/**
+ * Failure categories that are safe to auto-retry for read-only Pi nodes.
+ *
+ * These are failures with no repository write side-effects: model connection
+ * interruption, provider rate-limiting, temporary provider unavailability,
+ * request timeout, or a settled read-only turn with no assistant text.
+ *
+ * `quota` is intentionally NOT included: a quota exhaustion is an account
+ * billing/plan state, not a transient rate limit, and retrying immediately
+ * will not help and may waste budget.
+ */
+export const DEFAULT_DAG_RETRY_CATEGORIES = [
+    "timeout",
+    "network",
+    "rate-limit",
+    "unavailable",
+    "empty-output",
+];
+export const STRUCTURED_OUTPUT_RETRY_CATEGORY = "output-too-large";
+export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
+/** Recoverable model artifact/schema formatting failure on read-only structured nodes. */
+export const STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY = "invalid-output";
+/** Provider stopReason=length truncated the response before the JSON contract completed. */
+export const STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY = "structured-output-truncated";
+/**
+ * The review node emitted a verdict in response text (e.g. "VERDICT: pass")
+ * but never committed the authoritative typed terminal tool call
+ * (approve_review / request_review_changes). Read-only and safe to retry with
+ * a corrected instruction; the typed terminal is the only authority.
+ */
+export const REVIEW_TERMINAL_MISSING_RETRY_CATEGORY = "review-terminal-missing";
+/**
+ * The plan node issued too many read-only tool calls (read/grep/ls/find),
+ * blowing up the context window and eventually a 400 request-too-large. The
+ * plan should trust upstream typed facts instead of re-reading contract/scout
+ * outputs and source files repeatedly. Read-only and safe to retry with a
+ * reduced-reading instruction.
+ */
+export const READ_BURST_RETRY_CATEGORY = "read-burst";
+/**
+ * Provider returned a context-overflow error (400 request-too-large / context
+ * window exceeded). The SDK compacts and auto-retries once internally; when it
+ * still surfaces, the executor classifies this so retry policies and reports
+ * treat it as overflow (not empty-output) and can retry with a compacted
+ * session / fresh context.
+ */
+export const CONTEXT_OVERFLOW_RETRY_CATEGORY = "context-overflow";
+/** Retry only a proven no-op from an explicitly opt-in bounded Pi writer. */
+export const WRITER_EMPTY_DIFF_RETRY_CATEGORY = "writer-empty-diff";
+/** Retry when a backend-test writer finished but Completeness Gate found missing/broken targets. */
+export const INCOMPLETE_WRITE_SET_RETRY_CATEGORY = "incomplete-write-set";
+/**
+ * Provider/transport stall or absolute timeout on a Pi exclusive writer that
+ * left zero attributed workspace writes and zero write-tool calls. Safe to
+ * retry once because the attempt was a pure provider flake (no side effects).
+ * Partial writes keep the original `timeout` category and do NOT retry.
+ */
+export const WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY = "writer-clean-timeout";
+export const STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    STRUCTURED_OUTPUT_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
+];
+/** Categories allowed on nodes that declare a machine-readable outputProtocol. */
+export const PROTOCOL_AWARE_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    PROTOCOL_INVALID_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+];
+export const ALL_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    STRUCTURED_OUTPUT_RETRY_CATEGORY,
+    PROTOCOL_INVALID_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
+    WRITER_EMPTY_DIFF_RETRY_CATEGORY,
+    INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+    WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,
+    REVIEW_TERMINAL_MISSING_RETRY_CATEGORY,
+    READ_BURST_RETRY_CATEGORY,
+    CONTEXT_OVERFLOW_RETRY_CATEGORY,
+];
+export const dagRetryCategorySchema = z.enum(ALL_DAG_RETRY_CATEGORIES);
+export const dagRetryBackoffSchema = z.enum(["exponential"]);
+/**
+ * Opt-in retry policy for a DagTask. Generated for safe read-only Pi nodes,
+ * except the single validation-gated writer-empty-diff policy. Validation
+ * rejects all other writers, dynamic, shell, static, and decision-gate nodes.
+ */
+export const dagRetryPolicySchema = z
+    .object({
+    /**
+     * Total number of attempts (including the first try). Must be 1..5.
+     * A value of 1 disables retry (one attempt, no retry).
+     */
+    maxAttempts: z.number().int().positive().max(5),
+    backoff: dagRetryBackoffSchema.default("exponential"),
+    /** Initial delay before the second attempt, in milliseconds. */
+    initialDelayMs: z.number().int().nonnegative().default(2000),
+    /** Upper bound on a single backoff delay, in milliseconds. */
+    maxDelayMs: z.number().int().nonnegative().default(30000),
+    /**
+     * Explicit set of failure categories eligible for retry. Defaults to
+     * {@link DEFAULT_DAG_RETRY_CATEGORIES}. `quota` and other categories
+     * are never retried.
+     */
+    retryCategories: z
+        .array(dagRetryCategorySchema)
+        .default([...DEFAULT_DAG_RETRY_CATEGORIES]),
+})
+    .superRefine((policy, ctx) => {
+    if (policy.maxDelayMs < policy.initialDelayMs) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "retryPolicy.maxDelayMs must be >= retryPolicy.initialDelayMs",
+            path: ["maxDelayMs"],
+        });
+    }
+});
+export const TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE = "standard-reviewed-supervised-v1";