@tea-agent/loop-agent 0.40.0-next.8 → 0.40.0

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) {
@@ -884,28 +895,23 @@ export function isBackendTestShardChildTask(task) {
         task.id?.startsWith("generate-backend-pytest-case-"));
 }
 /**
- * Is this task the README-only plan node of the map-sharded md topology?
- * The plan node writes testcase/md/README.md alone; module case cards are
- * produced by the downstream map_agent children, so the Completeness Gate
- * must NOT require module files to exist at plan time.
+ * Historical classifier for the Markdown plan node. Current backend-test N2
+ * is read-only and persists a run-owned plan.md, so writer completeness never
+ * invokes the workspace README assessment below for newly generated DAGs.
  */
 export function isBackendTestMdPlanTask(task) {
     return task.id === "generate-backend-md-plan-pi";
 }
 /**
- * Is this task the shared-resources plan node of the map-sharded pytest
- * topology? The plan node writes helpers/factories only; per-module pytest
- * scripts are produced by the downstream map_agent children, so the Gate
- * must NOT require mapped pytest scripts to exist at plan time.
+ * Historical classifier for the former shared-resources pytest writer. Current
+ * N7 is static and every map child writes one self-contained pytest module.
  */
 export function isBackendTestPytestPlanTask(task) {
     return task.id === "generate-backend-pytest-plan-pi";
 }
 /**
- * Plan-node completeness for the md topology: verify the README itself is
- * structurally complete (Coverage Scope, Coverage Matrix, a non-empty module
- * index), WITHOUT requiring the indexed module files to exist yet — those are
- * written by the downstream map_agent shard children.
+ * Legacy workspace-plan completeness helper retained for isolated historical
+ * fixtures. New DAGs validate the run-owned plan artifact in N3 instead.
  */
 export async function assessBackendTestMdPlanCompleteness(workspaceRoot, layout) {
     const resolvedPlan = layout ?? resolveBackendTestLayout(undefined);