@tea-agent/loop-agent 0.40.0-next.10 → 0.40.0-next.12

package/dist/workflows/dag/backend-test-case-coverage-analysis.js

@@ -8,6 +8,7 @@ import { resolveBackendTestLayout, } from "./backend-test-layout.js";
 import { resolveBackendTestManifestModules, backendManifestStatusFinding } from "./backend-test-markdown-workflow.js";
 import { applyOpenApiPartitionDomainPolicy, assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
+import { inferScenarioParamIntent } from "./backend-test-scenario-param.js";
 const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{3})\b.*$/gm;
 const CASE_ID_IN_TEXT = /\bBE-[A-Z0-9_-]+-\d{3}\b/g;
 const NON_CANONICAL_CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-(?:\d{2}|\d{2,3}[A-Z]+))\b.*$/gm;
@@ -281,6 +282,80 @@ export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
     entries: z.array(correspondenceEntrySchema),
     findings: z.array(z.string()),
 }).strict();
+function bindingCounts(entry) {
+    const counts = new Map();
+    for (const point of [...entry.variantTestPoints, ...entry.assertionTestPoints, ...entry.crossCuttingTestPoints]) {
+        counts.set(point, (counts.get(point) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Classify correspondence defects by the only writer that can safely repair
+ * them. Markdown-owned contract defects must be fixed before pytest generation;
+ * pytest-owned generated-asset defects may enter the single bounded N11 repair.
+ */
+export function classifyBackendTestCorrespondenceRepair(facts, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const scriptRoot = resolved.scriptDir.replace(/\/$/, "");
+    const safePytestPath = (candidate) => {
+        const normalized = candidate.replaceAll("\\", "/").replace(/^\.\//, "");
+        return normalized.endsWith(".py") && (normalized === scriptRoot || normalized.startsWith(`${scriptRoot}/`));
+    };
+    const markdownBlockingEntries = [];
+    const pytestRepairEntries = [];
+    for (const entry of facts.entries) {
+        const markdownReasons = [];
+        const pytestReasons = [];
+        const counts = bindingCounts(entry);
+        if (entry.testPoints.some((point) => (counts.get(point) ?? 0) !== 1) ||
+            [...counts.keys()].some((point) => !entry.testPoints.includes(point))) {
+            markdownReasons.push("markdown-test-point-binding-invalid");
+        }
+        if (entry.declaredScript && entry.declaredScript !== entry.expectedScript) {
+            markdownReasons.push("markdown-script-declaration-invalid");
+        }
+        if (entry.cardinality === "1:0")
+            pytestReasons.push("missing-pytest-symbol");
+        if (entry.cardinality === "1:N")
+            pytestReasons.push("multiple-pytest-symbols");
+        if (entry.cardinality === "0:1")
+            pytestReasons.push("extra-pytest-symbol");
+        if (entry.actualScripts.some((script) => script !== entry.expectedScript))
+            pytestReasons.push("pytest-script-mismatch");
+        if (entry.declaredPrimarySymbol && entry.pytestSymbols.some((symbol) => symbol !== entry.declaredPrimarySymbol)) {
+            pytestReasons.push("pytest-primary-symbol-mismatch");
+        }
+        if (entry.variantTestPoints.some((point) => !entry.parameterIds.includes(point)))
+            pytestReasons.push("variant-parameter-missing");
+        if (entry.assertionTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+            pytestReasons.push("assertion-binding-missing");
+        if (entry.crossCuttingTestPoints.some((point) => !entry.mappedTestPoints.includes(point)))
+            pytestReasons.push("cross-cutting-binding-missing");
+        if (entry.parameterIds.some((point) => !entry.testPoints.includes(point)))
+            pytestReasons.push("pytest-test-point-binding-extra");
+        if (entry.payloadAssessment.status === "UNSAFE")
+            pytestReasons.push("pytest-payload-shape-mismatch");
+        if (entry.status !== "EXACT_1_TO_1" &&
+            !["TEST_POINT_BINDING_DUPLICATE", "PAYLOAD_CONTRACT_UNAVAILABLE"].includes(entry.status)) {
+            pytestReasons.push(`correspondence-${entry.status.toLowerCase().replaceAll("_", "-")}`);
+        }
+        if (entry.status === "PAYLOAD_CONTRACT_UNAVAILABLE") {
+            markdownReasons.push("markdown-payload-contract-unavailable");
+        }
+        const paths = orderedUnique([entry.expectedScript, ...entry.actualScripts].filter(safePytestPath));
+        if (markdownReasons.length > 0) {
+            markdownBlockingEntries.push({ ...(entry.caseId ? { caseId: entry.caseId } : {}), reasonCodes: orderedUnique(markdownReasons), paths });
+        }
+        if (pytestReasons.length > 0 && paths.length > 0) {
+            pytestRepairEntries.push({ ...(entry.caseId ? { caseId: entry.caseId } : {}), reasonCodes: orderedUnique(pytestReasons), paths });
+        }
+    }
+    return {
+        markdownBlockingEntries,
+        pytestRepairEntries,
+        pytestRepairPaths: orderedUnique(pytestRepairEntries.flatMap((entry) => entry.paths)).sort(),
+    };
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -593,6 +668,19 @@ function automationLabelBody(body, labels) {
     const match = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:]\\s*(.*)$`, "mi").exec(automation);
     return match?.[1]?.replaceAll("`", "").trim() ?? "";
 }
+export function inspectBackendTestMarkdownTestPointBindings(markdown) {
+    const headings = [...markdown.matchAll(CASE_HEADING)];
+    return headings.map((heading, index) => {
+        const body = markdown.slice(heading.index, headings[index + 1]?.index ?? markdown.length);
+        const testPoints = listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT);
+        const bindings = testPointBindingFacts(body, testPoints);
+        return {
+            caseId: canonicalCaseId(heading[1]),
+            unclassifiedTestPoints: bindings.unclassifiedTestPoints,
+            duplicateBindingTestPoints: bindings.duplicateBindingTestPoints,
+        };
+    });
+}
 function testPointBindingFacts(body, testPoints) {
     const bindings = TEST_POINT_BINDING_MODES.flatMap((mode) => {
         const value = automationLabelBody(body, AUTOMATION_BINDING_LABELS[mode]);
@@ -1404,6 +1492,11 @@ def payload_expr_nodes(expr, assigned, parameters, seen=None):
                 if isinstance(key,ast.Constant) and key.value == expr.slice.value:
                     result.extend(shape_only(item) for item in payload_expr_nodes(value,assigned,parameters,set(seen)))
         return result
+    if isinstance(expr,ast.IfExp):
+        result=[]
+        result.extend(payload_expr_nodes(expr.body,assigned,parameters,set(seen)))
+        result.extend(payload_expr_nodes(expr.orelse,assigned,parameters,set(seen)))
+        return result
     if isinstance(expr,ast.Call):
         result=[]
         if isinstance(expr.func,ast.Name) and expr.func.id in FUNCTION_PAYLOADS:
@@ -1444,6 +1537,30 @@ def decorator_payload_nodes(parameters,assigned):
         for value in values: result.extend(payload_expr_nodes(value,assigned,parameters))
     return result
 
+def decorator_payload_nodes_by_tp(fn,assigned):
+    result={}
+    for dec in fn.decorator_list:
+        if not isinstance(dec,ast.Call) or not isinstance(dec.func,ast.Attribute) or dec.func.attr != 'parametrize' or len(dec.args) < 2: continue
+        if not isinstance(dec.args[0],ast.Constant) or not isinstance(dec.args[0].value,str): continue
+        names=[item.strip() for item in dec.args[0].value.split(',')]
+        rows=dec.args[1]
+        if isinstance(rows,ast.Name) and rows.id in GLOBAL_VALUES: rows=GLOBAL_VALUES[rows.id]
+        for node in ast.walk(rows):
+            if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Attribute) or node.func.attr != 'param': continue
+            tp=None
+            for keyword in node.keywords:
+                if keyword.arg == 'id' and isinstance(keyword.value,ast.Constant) and isinstance(keyword.value.value,str) and keyword.value.value.startswith('TP-'):
+                    tp=keyword.value.value
+            if not tp: continue
+            parameters={}
+            for index,name in enumerate(names):
+                if index < len(node.args): parameters.setdefault(name,[]).append(node.args[index])
+            payload_nodes=decorator_payload_nodes(parameters,assigned)
+            paths=set(); values={}
+            for payload_node in payload_nodes: collect_dict(payload_node,'',paths,values)
+            result[tp]={key:sorted(items) for key,items in sorted(values.items())}
+    return result
+
 def fallback_payload_nodes(fn):
     result=[]
     assigned={}
@@ -1473,7 +1590,7 @@ def fallback_payload_nodes(fn):
 
 def is_direct_transport_call(node):
     if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Attribute): return False
-    if node.func.attr.lower() not in {'get','post','put','patch','delete','request'}: return False
+    if node.func.attr.lower() not in {'get','post','put','patch','delete','request','call'}: return False
     receiver_tokens=[]
     current=node.func.value
     while isinstance(current,ast.Attribute):
@@ -1521,6 +1638,7 @@ for fn in ast.walk(tree):
             'values':{key:sorted(items) for key,items in sorted(values.items())},
             'fallbackPaths':sorted(fallback_paths),
             'fallbackValues':{key:sorted(items) for key,items in sorted(fallback_values.items())},
+            'valuesByTestPoint':decorator_payload_nodes_by_tp(fn,{}),
         }
 print(json.dumps(out,ensure_ascii=True))
 `;
@@ -1651,6 +1769,7 @@ function pytestSymbols(script, source) {
             payloadValues: payloadShape.values,
             fallbackPayloadPaths: payloadShape.fallbackPaths ?? [],
             fallbackPayloadValues: payloadShape.fallbackValues ?? {},
+            payloadValuesByTestPoint: payloadShape.valuesByTestPoint ?? {},
         };
     });
 }
@@ -1664,6 +1783,33 @@ function executionSignature(testCase) {
         .join("\n");
     return createHash("sha256").update(normalized).digest("hex");
 }
+function normalizePythonLiteralValue(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function intentionalInvalidEnumVariant(input) {
+    if (!input.testCase.testPointBindings.some((binding) => binding.mode === "variant" && binding.testPoint === input.testPoint))
+        return false;
+    const inferred = inferScenarioParamIntent({ tpId: input.testPoint, caseBody: input.testCase.body });
+    if (inferred.intentSource !== "machine-line" || inferred.field?.toLowerCase() !== input.field.toLowerCase())
+        return false;
+    const observed = normalizePythonLiteralValue(input.observedValue);
+    if (input.allowed.includes(observed))
+        return false;
+    if (inferred.intent === "enum-invalid" || inferred.intent === "wrong-type")
+        return true;
+    if (inferred.intent === "null")
+        return observed === "None" || observed === "null";
+    if (inferred.intent === "empty")
+        return observed === "";
+    if (!inferred.intent.startsWith("custom-literal:"))
+        return false;
+    const expected = normalizePythonLiteralValue(inferred.example ?? inferred.intent.slice("custom-literal:".length));
+    return observed === expected;
+}
 function assessPayloadContract(testCase, refs) {
     const requiredPaths = testCase.payloadContract.requiredPaths;
     const directObservedPaths = orderedUnique(refs.flatMap((item) => item.payloadPaths));
@@ -1685,13 +1831,17 @@ function assessPayloadContract(testCase, refs) {
             ? observedPaths.filter((item) => !allowedPaths.includes(item) && !allowedPaths.some((allowed) => item.startsWith(`${allowed}.`)))
             : [];
     const enumMismatches = [];
-    const delegatesInvalidEnumToScenarioGate = testCase.testPointBindings
-        .filter((binding) => binding.mode === "variant")
-        .some((binding) => /(?:ENUM|CATEGORY).*(?:INVALID|UNKNOWN|CASE|WHITESPACE|EMPTY|WRONG-TYPE)|(?:INVALID|UNKNOWN|CASE|WHITESPACE|EMPTY|WRONG-TYPE).*(?:ENUM|CATEGORY)/.test(binding.testPoint));
     for (const [field, allowed] of Object.entries(testCase.payloadContract.enumValues)) {
-        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []).map((value) => value.replace(/^['"]|['"]$/g, "")));
-        for (const value of observed) {
-            if (!allowed.includes(value) && !delegatesInvalidEnumToScenarioGate)
+        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        for (const rawValue of observed) {
+            const value = normalizePythonLiteralValue(rawValue);
+            if (allowed.includes(value))
+                continue;
+            const associatedTestPoints = orderedUnique(refs.flatMap((item) => Object.entries(item.payloadValuesByTestPoint)
+                .filter(([, values]) => (values[field] ?? []).includes(rawValue))
+                .map(([testPoint]) => testPoint)));
+            const intentionallyInvalid = associatedTestPoints.length > 0 && associatedTestPoints.every((testPoint) => intentionalInvalidEnumVariant({ testCase, testPoint, field, observedValue: rawValue, allowed }));
+            if (!intentionallyInvalid)
                 enumMismatches.push(`${field}=${value}; allowed=${allowed.join("|")}`);
         }
     }

package/dist/workflows/dag/backend-test-pytest-collection.js

@@ -20,6 +20,14 @@ export const backendPytestCollectionFindingSchema = z.object({
     classification: z.literal("test-asset-defect"),
     repairability: z.enum(["repairable", "blocked"]),
     detail: z.string().min(1),
+    caseId: z.string().min(1).optional(),
+    reasonCodes: z.array(z.string().min(1)).optional(),
+    repairPaths: z.array(z.string().min(1)).optional(),
+    payloadExpectedPaths: z.array(z.string()).optional(),
+    payloadObservedPaths: z.array(z.string()).optional(),
+    payloadMissingPaths: z.array(z.string()).optional(),
+    payloadUnexpectedPaths: z.array(z.string()).optional(),
+    payloadEnumMismatches: z.array(z.string()).optional(),
 }).strict();
 export const backendPytestCollectionFactsSchema = z.object({
     schemaId: z.literal("backend-test-pytest-collection-v3"),
@@ -61,11 +69,22 @@ export const backendPytestCollectionFactsSchema = z.object({
         context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest fixture resolution without an attempt cannot have an exit code" });
     }
 });
+const backendTestScenarioParamDiagnosticSchema = z.object({
+    reasonCode: z.enum(["SCENARIO_PARAM_MISMATCH", "SCENARIO_PARAM_UNDETERMINED"]),
+    tpId: z.string().min(1).max(256),
+    field: z.string().min(1).max(256).optional(),
+    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(),
+}).strict();
 const backendTestExcludedItemSchema = z.object({
     itemId: z.string().min(1),
     caseId: z.string().optional(),
     symbol: z.string().optional(),
     reasons: z.array(z.string().min(1)).min(1),
+    scenarioParamDiagnostics: z.array(backendTestScenarioParamDiagnosticSchema).max(16).optional(),
 }).strict();
 export const backendTestExecutionReadinessSchema = z.object({
     schemaId: z.literal("backend-test-execution-readiness-v2"),
@@ -81,6 +100,14 @@ export const backendTestExecutionReadinessSchema = z.object({
     collectedItemIds: z.array(z.string()),
     eligibleItemIds: z.array(z.string()),
     excludedItems: z.array(backendTestExcludedItemSchema),
+    exclusionSummary: z.object({
+        excludedItemCount: z.number().int().min(0),
+        excludedCaseCount: z.number().int().min(0),
+        excludedByReason: z.record(z.string(), z.number().int().min(1)),
+        excludedByCase: z.record(z.string(), z.number().int().min(1)),
+    }).strict(),
+    pytestSpawned: z.literal(false),
+    businessTestBodyExecutedCount: z.literal(0),
     fixtureIssues: z.array(z.string()),
     assetHashes: z.record(z.string(), z.string().regex(SHA256)),
     eligibilityInputHashes: z.record(z.string(), z.string().regex(SHA256)),
@@ -702,6 +729,7 @@ export function buildBackendTestItemEligibility(collectedItemIds, input) {
         const parameterTokens = orderedUnique((itemId.match(/TP-[A-Z0-9-]+/g) ?? []));
         const mapping = input.correspondenceEntries.find((entry) => symbol && (entry.declaredPrimarySymbol === symbol || entry.pytestSymbols.includes(symbol)));
         const reasons = [];
+        const scenarioParamDiagnostics = [];
         if (!mapping)
             reasons.push("no exact Markdown Case/primary-symbol correspondence");
         if (mapping && mapping.status !== "EXACT_1_TO_1")
@@ -724,13 +752,30 @@ export function buildBackendTestItemEligibility(collectedItemIds, input) {
             // or observed Python payload shape.
             const normalizedField = entry.field?.toLowerCase();
             const fieldIsPayloadBound = Boolean(normalizedField && payloadPaths.some((item) => item === normalizedField || item.endsWith(`.${normalizedField}`)));
-            if (fieldIsPayloadBound && entry.status !== "MATCH")
+            if (fieldIsPayloadBound && entry.status !== "MATCH") {
                 reasons.push(`scenario-param ${entry.tpId} field ${entry.field} is ${entry.status}`);
+                scenarioParamDiagnostics.push({
+                    reasonCode: entry.status === "MISMATCH" ? "SCENARIO_PARAM_MISMATCH" : "SCENARIO_PARAM_UNDETERMINED",
+                    tpId: entry.tpId,
+                    ...(entry.field ? { field: entry.field } : {}),
+                    ...(entry.expectedRaw !== undefined ? { expectedRaw: entry.expectedRaw.slice(0, 512) } : {}),
+                    observedRaw: (entry.observedRaw ?? "unavailable").slice(0, 512),
+                    ...(entry.expectedNormalized !== undefined ? { expectedNormalized: entry.expectedNormalized.slice(0, 512) } : {}),
+                    ...(entry.observedNormalized !== undefined ? { observedNormalized: entry.observedNormalized.slice(0, 512) } : {}),
+                    ...(entry.sourceLocation ? { sourceLocation: entry.sourceLocation.slice(0, 512) } : {}),
+                });
+            }
         }
         if (reasons.length === 0)
             eligibleItemIds.push(itemId);
         else
-            excludedItems.push({ itemId, ...(mapping?.caseId ? { caseId: mapping.caseId } : {}), ...(symbol ? { symbol } : {}), reasons: orderedUnique(reasons) });
+            excludedItems.push({
+                itemId,
+                ...(mapping?.caseId ? { caseId: mapping.caseId } : {}),
+                ...(symbol ? { symbol } : {}),
+                reasons: orderedUnique(reasons),
+                ...(scenarioParamDiagnostics.length > 0 ? { scenarioParamDiagnostics: scenarioParamDiagnostics.slice(0, 16) } : {}),
+            });
     }
     return { eligibleItemIds, excludedItems };
 }
@@ -763,6 +808,9 @@ export async function materializeBackendTestExecutionReadiness(input) {
         collectedItemIds: input.effective.collectedItemIds,
         eligibleItemIds: eligibility.eligibleItemIds,
         excludedItems: eligibility.excludedItems,
+        exclusionSummary: summarizeBackendTestExclusions(eligibility.excludedItems),
+        pytestSpawned: false,
+        businessTestBodyExecutedCount: 0,
         fixtureIssues: input.effective.findings.filter((item) => /fixture/i.test(item.kind)).map((item) => item.detail),
         assetHashes: input.effective.inputHashes,
         eligibilityInputHashes: input.eligibilityInputHashes ?? {},
@@ -778,6 +826,26 @@ export async function readBackendTestExecutionReadiness(filePath) {
 function formatReadinessCounts(readiness) {
     return `mapped=${readiness.mappedScripts.length} collected=${readiness.collectedItemIds.length} eligible=${readiness.eligibleItemIds.length} excluded=${readiness.excludedItems.length}`;
 }
+export function summarizeBackendTestExclusions(excludedItems) {
+    const reasonCounts = new Map();
+    const caseCounts = new Map();
+    for (const item of excludedItems) {
+        if (item.caseId)
+            caseCounts.set(item.caseId, (caseCounts.get(item.caseId) ?? 0) + 1);
+        for (const reason of item.reasons) {
+            const category = classifyExclusionReason(reason);
+            reasonCounts.set(category, (reasonCounts.get(category) ?? 0) + 1);
+        }
+    }
+    return {
+        excludedItemCount: excludedItems.length,
+        excludedCaseCount: caseCounts.size,
+        excludedByReason: Object.fromEntries(READINESS_EXCLUSION_CATEGORIES
+            .filter((category) => (reasonCounts.get(category) ?? 0) > 0)
+            .map((category) => [category, reasonCounts.get(category)])),
+        excludedByCase: Object.fromEntries([...caseCounts.entries()].sort(([left], [right]) => left.localeCompare(right))),
+    };
+}
 export function classifyExclusionReason(reason) {
     if (reason === "no exact Markdown Case/primary-symbol correspondence")
         return "correspondence-missing";

package/dist/workflows/dag/backend-test-result-contract.js

@@ -70,6 +70,7 @@ export const backendTestResultContractSchema = z
     schemaVersion: z.literal(1),
     /** Process-level status of the pytest invocation. Task Pool: use with outcome. */
     executionStatus: backendTestExecutionStatusSchema,
+    pytestSpawned: z.literal(true),
     pytestExitCode: z.number().int().min(0).max(255),
     collectionStatus: backendTestCollectionStatusSchema,
     /** Total tests counted from JUnit (or 0 when report unavailable). */
@@ -659,6 +660,7 @@ export function deriveBackendTestResult(input) {
         const result = {
             schemaVersion: 1,
             executionStatus,
+            pytestSpawned: true,
             pytestExitCode: input.pytestExitCode,
             collectionStatus: "unknown",
             tests: 0,
@@ -733,6 +735,7 @@ export function deriveBackendTestResult(input) {
     const result = {
         schemaVersion: 1,
         executionStatus,
+        pytestSpawned: true,
         pytestExitCode: exit,
         collectionStatus,
         tests: parsed.tests,
@@ -936,6 +939,7 @@ export async function materializeBackendTestResultFromPytestHtml(input) {
     const result = backendTestResultContractSchema.parse({
         schemaVersion: 1,
         executionStatus,
+        pytestSpawned: true,
         pytestExitCode: exit,
         collectionStatus,
         tests: parsed.tests,