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

package/CHANGELOG.md

@@ -28,6 +28,14 @@
 
 ### 修复
 
+- 修复文档审计扫描本地 `.scratch/` 临时证据与打包目录、导致仓库 preflight 和发布前验证被非治理文件阻断的问题。
+- 修复 backend-test 把 Markdown 明确声明的 enum-invalid、wrong-type、null、empty 和精确非法 custom literal 当作 payload enum 契约漂移、错误消耗唯一一次 pytest repair 的问题；豁免现在按 pytest parameter ID、目标字段和值逐 TP 绑定，positive/nominal drift 与 path 缺陷仍严格阻断。
+- 修复 backend-test 无法从同一生成模块的安全 payload helper 中绑定 field-target positional/keyword/default 参数，以及无法识别精确 `_without(payload, field)` 删除语义的问题；computed、动态、二层、跨模块和危险 helper 仍保持 `UNDETERMINED`。
+- 修复 backend-test 无法静态证明同一生成模块内安全 payload helper、导致 request-level nominal 场景长期停留在 `UNDETERMINED` 的问题；超长边界 observed 现在持久化为有界摘要并保留真实长度，空白修复建议也明确使用真实空格而非字面 escape 文本。
+- 修复 backend-test 把 Markdown 中 `\\u0020`/`\\x20` 空白表示与 pytest 真实空白字符串误判为 scenario-param 不一致的问题；readiness 的逐项排除现在携带有界的 TP、字段、expected/observed raw/normalized 和源码位置诊断，同时不对普通业务字符做 trim、大小写折叠或宽松解码。
+- 修复 Console 把 backend-test writer 的局部保护文件误判为整个 writeSet 越界的问题；任务级禁止路径仍保持硬阻断，合法 DAG 可继续取得 autonomous execution receipt。
+- 修复 backend-test 对 `resource_client.call(..., payload=...)` 一类本地 transport 的 payload AST 假阴性；readiness 新增固定分类/Case 排除汇总和 pytest 启动事实，payload repair finding 同时携带 expected/observed/missing path 清单。
+- 修复后端测试在 payload、fixture 与 Markdown→pytest 对应关系同时异常时只修复其中一类问题的问题；pytest 侧缺陷现在通过结构化 `repairFindings` 合并进入唯一一次有界 repair，Markdown Test Point 未分类或重复分类则在生成阶段定向重试并禁止下游猜修。
 - 修复重命名会话时输入框没有回显当前标题的问题。
 - 修复停止回复后输入区恢复迟缓、排队消息偶发丢失，以及切换会话后旧状态残留的问题。
 - 修复宽表格、文件预览、滚动条和窄屏布局中的多处显示异常。

package/dist/application/dag/generate-task-dag.js

@@ -109,8 +109,12 @@ function findForbiddenOverlapsForPacket(task) {
     const overlaps = [];
     for (const writeSetEntry of task.writeSet ?? []) {
         for (const forbiddenPath of task.forbiddenPaths ?? []) {
-            if (pathMatchesPattern(writeSetEntry, forbiddenPath) ||
-                pathMatchesPattern(forbiddenPath, writeSetEntry)) {
+            // A narrower forbidden child may intentionally carve a protected
+            // file out of a broader node writeSet. The runtime write guard gives
+            // forbiddenPaths precedence; report a packet conflict only when the
+            // writeSet entry itself is inside the forbidden boundary. Console G2
+            // separately rechecks task-global forbidden paths with live scope.
+            if (pathMatchesPattern(writeSetEntry, forbiddenPath)) {
                 overlaps.push({ writeSetEntry, forbiddenPath });
             }
         }

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.40.0-next.10",
-  "gitSha": "d108eb1087e69b3b84bc5c81d86e561adb5fb051",
-  "builtAt": "2026-08-28T01:40:07.616Z"
+  "version": "0.40.0-next.11",
+  "gitSha": "a23cf8d31616835f9fa670d7135ee4a5bd84feba",
+  "builtAt": "2026-08-28T16:52:35.690Z"
 }

package/dist/executors/shell-executor.js

@@ -32,11 +32,11 @@ import { materializeBackendTestExecutionContract } from "../workflows/dag/backen
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
 import { frontendTestLayoutFromSpec, } from "../workflows/dag/frontend-test-layout.js";
 import { backendTestGapDocSchema, ingestBackendTestGap, } from "../workflows/dag/backend-test-gap-fill.js";
-import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
+import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, classifyBackendTestCorrespondenceRepair, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, hasBlockingBackendMarkdownModuleStemFindings, inspectBackendTestEnvironment, markdownFiles, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
-import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, summarizeBackendTestExclusions, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -870,26 +870,49 @@ async function executeBackendTestPipeline(input, meta) {
                 const correspondenceFactsPath = path.join(contractsDir, "backend-test-markdown-pytest-correspondence-initial.json");
                 await writeFile(correspondenceFactsPath, JSON.stringify(correspondence.facts, null, 2), "utf8");
                 outputs.push(`initialCorrespondence=${correspondenceReportPath}`, `initialCorrespondenceFacts=${correspondenceFactsPath}`);
-                if (correspondence.facts.status === "FAIL" && facts.status === "PASS") {
-                    const correspondenceRepairPaths = Array.from(new Set(correspondence.facts.entries
-                        .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                        .flatMap((entry) => [entry.expectedScript, ...entry.actualScripts])
-                        .filter((candidate) => candidate.startsWith("testcase/") && candidate.endsWith(".py")))).sort();
-                    if (correspondenceRepairPaths.length > 0) {
-                        facts.status = "REPAIRABLE";
-                        facts.repairEligible = true;
-                        facts.repairPaths = Array.from(new Set([...facts.repairPaths, ...correspondenceRepairPaths])).sort();
+                if (correspondence.facts.status === "FAIL") {
+                    const repair = classifyBackendTestCorrespondenceRepair(correspondence.facts, backendLayout);
+                    if (repair.markdownBlockingEntries.length > 0) {
+                        facts.status = "BLOCKED";
+                        facts.repairEligible = false;
+                        facts.repairPaths = [];
                         facts.findings.push({
-                            kind: "markdown-pytest-correspondence",
+                            kind: "markdown-correspondence-contract",
                             classification: "test-asset-defect",
-                            repairability: "repairable",
-                            detail: correspondence.facts.entries
-                                .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                                .flatMap((entry) => entry.findings)
+                            repairability: "blocked",
+                            detail: repair.markdownBlockingEntries
+                                .map((entry) => `${entry.caseId ?? "unknown Case"}: ${entry.reasonCodes.join(", ")}`)
                                 .join("; ")
-                                .slice(0, 12_000) || "Markdown-to-pytest correspondence is incomplete",
+                                .slice(0, 12_000),
                         });
                     }
+                    else if (repair.pytestRepairPaths.length > 0 &&
+                        (facts.status === "PASS" || facts.status === "REPAIRABLE")) {
+                        facts.status = "REPAIRABLE";
+                        facts.repairEligible = true;
+                        facts.repairPaths = Array.from(new Set([...facts.repairPaths, ...repair.pytestRepairPaths])).sort();
+                        const repairEntries = correspondence.facts.entries.filter((entry) => repair.pytestRepairEntries.some((candidate) => candidate.caseId === entry.caseId));
+                        for (const entry of repairEntries.slice(0, 40)) {
+                            const classified = repair.pytestRepairEntries.find((candidate) => candidate.caseId === entry.caseId);
+                            facts.findings.push({
+                                kind: "markdown-pytest-correspondence",
+                                classification: "test-asset-defect",
+                                repairability: "repairable",
+                                detail: entry.findings.join("; ").slice(0, 2_000) || "Markdown-to-pytest correspondence is incomplete",
+                                ...(entry.caseId ? { caseId: entry.caseId } : {}),
+                                reasonCodes: classified?.reasonCodes ?? [],
+                                repairPaths: classified?.paths ?? [],
+                                payloadExpectedPaths: Array.from(new Set([
+                                    ...entry.payloadAssessment.requiredPaths,
+                                    ...entry.payloadAssessment.allowedPaths,
+                                ])).sort(),
+                                payloadObservedPaths: entry.payloadAssessment.observedPaths,
+                                payloadMissingPaths: entry.payloadAssessment.missingPaths,
+                                payloadUnexpectedPaths: entry.payloadAssessment.unexpectedPaths,
+                                payloadEnumMismatches: entry.payloadAssessment.enumMismatches,
+                            });
+                        }
+                    }
                 }
             }
             catch (error) {
@@ -912,6 +935,19 @@ async function executeBackendTestPipeline(input, meta) {
                     collectedItemCount: facts.collectedItemCount,
                     missingMappedScripts: facts.missingMappedScripts,
                     repairPaths: facts.repairPaths,
+                    repairFindings: facts.findings.map((finding) => ({
+                        kind: finding.kind,
+                        repairability: finding.repairability,
+                        detail: finding.detail,
+                        ...(finding.caseId ? { caseId: finding.caseId } : {}),
+                        ...(finding.reasonCodes ? { reasonCodes: finding.reasonCodes } : {}),
+                        ...(finding.repairPaths ? { repairPaths: finding.repairPaths } : {}),
+                        ...(finding.payloadExpectedPaths ? { payloadExpectedPaths: finding.payloadExpectedPaths } : {}),
+                        ...(finding.payloadObservedPaths ? { payloadObservedPaths: finding.payloadObservedPaths } : {}),
+                        ...(finding.payloadMissingPaths ? { payloadMissingPaths: finding.payloadMissingPaths } : {}),
+                        ...(finding.payloadUnexpectedPaths ? { payloadUnexpectedPaths: finding.payloadUnexpectedPaths } : {}),
+                        ...(finding.payloadEnumMismatches ? { payloadEnumMismatches: finding.payloadEnumMismatches } : {}),
+                    })),
                     factsPath: "contracts/backend-test-pytest-collection-initial.json",
                 }),
                 stderr: "",
@@ -1011,6 +1047,7 @@ async function executeBackendTestPipeline(input, meta) {
                 })
                 : { eligibleItemIds: effective.collectedItemIds, excludedItems: [] };
             const eligibilityInputHashes = Object.fromEntries((correspondence?.facts.inputFiles ?? []).map((item) => [item.path, item.sha256]));
+            const exclusionSummary = summarizeBackendTestExclusions(eligibility.excludedItems);
             const eligibilityFactsPath = path.join(meta.runDir, "contracts", "backend-test-execution-eligibility.json");
             await mkdir(path.dirname(eligibilityFactsPath), { recursive: true });
             await writeFile(eligibilityFactsPath, `${JSON.stringify({
@@ -1021,6 +1058,9 @@ async function executeBackendTestPipeline(input, meta) {
                 excludedItemCount: eligibility.excludedItems.length,
                 eligibleItemIds: eligibility.eligibleItemIds,
                 excludedItems: eligibility.excludedItems,
+                exclusionSummary,
+                pytestSpawned: false,
+                businessTestBodyExecutedCount: 0,
                 inputHashes: eligibilityInputHashes,
             }, null, 2)}\n`, "utf8");
             const eligibilityReportPath = await writeRunReport(meta.runDir, "backend-test-execution-eligibility.md", [
@@ -1033,6 +1073,10 @@ async function executeBackendTestPipeline(input, meta) {
                 `- Collected items: ${effective.collectedItemIds.length}`,
                 `- Eligible items: ${eligibility.eligibleItemIds.length}`,
                 `- Excluded items: ${eligibility.excludedItems.length}`,
+                `- Excluded Cases: ${exclusionSummary.excludedCaseCount}`,
+                `- Exclusion categories: ${Object.entries(exclusionSummary.excludedByReason).map(([category, count]) => `${category}=${count}`).join("; ") || "none"}`,
+                "- pytest spawned: false",
+                "- Business test bodies executed: 0",
                 "",
                 "## Excluded Items",
                 "",
@@ -1061,6 +1105,9 @@ async function executeBackendTestPipeline(input, meta) {
                     executionReadinessStatus: readiness.status,
                     eligibleItemCount: readiness.eligibleItemIds.length,
                     excludedItemCount: readiness.excludedItems.length,
+                    exclusionSummary: readiness.exclusionSummary,
+                    pytestSpawned: readiness.pytestSpawned,
+                    businessTestBodyExecutedCount: readiness.businessTestBodyExecutedCount,
                     factsPath: "contracts/backend-test-pytest-collection-effective.json",
                     readinessPath: "contracts/backend-test-execution-readiness.json",
                     reportPath: artifacts.reportPath,

package/dist/governance/checks.js

@@ -8,6 +8,7 @@ import { buildTaskReadModel } from '../task/read-model.js';
 const SKIP_DIRS = new Set([
     '.git',
     '.harness',
+    '.scratch',
     'node_modules',
     'dist',
     'coverage',

package/dist/worker/console/dag-execution-receipt.js

@@ -176,8 +176,26 @@ export function deriveEligibilityFactsFromDagSpec(input) {
     }));
     const allWriteSetEntries = writers.flatMap((writer) => writer.writeSet);
     const broadWriteSetRisk = allWriteSetEntries.some(isBroadWriteSetEntry);
-    const forbiddenOverlapRisk = tasks.some((task) => stringList(task.writeSet).some((entry) => [...stringList(task.forbiddenPaths), ...input.forbiddenPaths].some((forbidden) => pathMatchesPattern(entry, forbidden) ||
-        pathMatchesPattern(forbidden, entry))));
+    const taskForbidden = input.forbiddenPaths.map(normalizePathEntry);
+    const forbiddenOverlapRisk = tasks.some((task) => stringList(task.writeSet).some((entry) => {
+        const normalizedEntry = normalizePathEntry(entry);
+        return stringList(task.forbiddenPaths).some((forbidden) => {
+            const normalizedForbidden = normalizePathEntry(forbidden);
+            const isTaskGlobal = taskForbidden.includes(normalizedForbidden);
+            if (isTaskGlobal) {
+                // Task-level forbidden paths are hard global boundaries. A broad
+                // writer that could include one is not autonomously eligible.
+                return (pathMatchesPattern(normalizedEntry, normalizedForbidden) ||
+                    pathMatchesPattern(normalizedForbidden, normalizedEntry));
+            }
+            // Node-local forbidden paths may intentionally carve a narrower
+            // child (for example md/README.md) out of a broader writer
+            // writeSet. That exclusion is enforced by the runtime write guard.
+            // It is a conflict only when the writer entry itself is wholly
+            // inside the forbidden boundary.
+            return pathMatchesPattern(normalizedEntry, normalizedForbidden);
+        });
+    }));
     const hasStructuredVerification = tasks.some((task) => {
         if (task.executor !== "shell" || !task.shell)
             return false;

package/dist/worker/console/operator-actions.js

@@ -1641,9 +1641,10 @@ export async function dispatchOperatorAction(ctx, req) {
                 broadWriteSetRisk: typeof reviewPacket.broadWriteSetRisk === "boolean"
                     ? reviewPacket.broadWriteSetRisk
                     : derivedFacts.broadWriteSetRisk,
-                forbiddenOverlapRisk: typeof reviewPacket.forbiddenOverlapRisk === "boolean"
-                    ? reviewPacket.forbiddenOverlapRisk
-                    : derivedFacts.forbiddenOverlapRisk,
+                // Always use the staged DAG + live task boundary derivation here.
+                // The generation review packet lacks task-boundary scope and can
+                // mistake a narrower node-local exclusion for a global overlap.
+                forbiddenOverlapRisk: derivedFacts.forbiddenOverlapRisk,
                 hasStructuredVerification: packetShellVerification,
             };
             const assessment = assessAutonomousExecutionEligibility(eligibility);

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,

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/init-hybrid.js

@@ -4815,7 +4815,7 @@ async function buildBackendTestHybridDag(sources) {
         writerOutcomePolicy: { type: "implementation-outcome-v1", requireChangedFiles: true },
         outputContract: "First non-empty line is IMPLEMENTATION_OUTCOME: changed|blocked, followed by a concise repair summary. This node runs only for REPAIRABLE initial facts, so already-satisfied is invalid and a successful outcome requires a non-empty bounded diff. Modify only generated pytest scripts/helpers/factories and preserve every Markdown Case, Test Point, primary symbol and assertion meaning.",
         subtask_prompt: [
-            "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution. Treat any upstream line such as `Repair paths: testcase/test_x.py` as complete authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.",
+            "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution. The direct upstream JSON includes authoritative `repairPaths` and bounded `repairFindings`; treat both as the complete mandatory checklist without searching for a run directory or report file. Treat any upstream line such as `Repair paths: testcase/test_x.py` as equivalent authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.",
             "Initial status REPAIRABLE means at least one listed finding remains: `already-satisfied` is forbidden, and you must produce a non-empty bounded diff on repairPaths before returning `IMPLEMENTATION_OUTCOME: changed`. Fix only readiness-proven generated testcase-local defects on initial facts repairPaths: create exact safe missing mapped test_*.py paths, repair syntax/import/symbol/decorator/parameterization, close generated fixture dependencies/plugin registration, and repair initial Markdown-to-pytest correspondence findings. Use this deterministic repair map instead of reading analyzer implementation: findings about `Case-ID`, `Assertion-Test-Points`, or `Cross-Cutting-Test-Points` are fixed by editing the declared primary symbol docstring metadata lines; variant binding findings are fixed in the literal direct `pytest.param(..., id=\"TP-...\")` row; primary-symbol cardinality/name findings are fixed in the function name or duplicate primary symbols; script mismatch is fixed only on the authoritative assessment repairPaths; payload findings are fixed in request payload construction. Do not read controller `src/**` or inspect JS/TS analyzer code. Do not search for `testcase/**/README.md`. Never invent a business pytest symbol for evidence-only Markdown Cases that declare `脚本/primary symbol=无` with empty variants. For fixture defects inspect both provider and importer listed by repairPaths; fix ScopeMismatch by aligning fixture scopes or inlining request-scoped values so module fixtures never depend on function fixtures; when a shared fixture depends on sibling fixtures, register the whole provider module through an exact pytest_plugins declaration rather than importing only the outer fixture. Do not create unrelated pytest scripts.",
             "This is the single pytest incremental synchronization round. The `Findings` in `reports/backend-test-pytest-collection-initial.md` are the mandatory repair checklist: resolve every repairable listed finding on every authoritative `Repair paths` file before considering any other advisory evidence, and never substitute an unrelated scenario-param cleanup for a listed correspondence/collection defect. For every assessment-listed path, compare the effective Markdown Case/Test Points/test data and its `Payload Contract`/`Payload Required Paths`/`Payload Allowed Paths`/`Payload Enum` labels with the generated module. Incrementally add or repair only missing symbols, params, assertions and payload builders. Repair every assessment-listed missing nested path, unexpected key and enum mismatch; preserve exact DTO keys, nested shapes, enum/boundary literals, operation transport and business preconditions; remove guessed replacement keys only when the effective Markdown proves the exact contract. Keep path/query/header identifiers and scenario-control metadata separate from DTO patches and JSON bodies; an `id` used for a path target must be passed to the request path/helper, never inserted into a body patch unless `id` is explicitly listed in Payload Allowed Paths. Flatten every variant into a literal direct `pytest.param(..., id=\"TP-...\")` row; replace `_post_case`/`_put_case` or other parameter-row factories because correspondence and scenario readiness require the actual row values and IDs to be statically visible. Also repair helper call sites to match their defined return signatures; do not tuple-unpack a helper that returns one scalar value.",
             "Preserve final testcase/md/** semantics, every Case ID, Rule/Test Point binding, primary symbol, parameter ID, expected status/body/schema assertion, HTTP logging, redaction and truncation behavior.",

package/docs/templates/backend-test-dag.json

@@ -504,7 +504,8 @@
 			"outputContract": "Run-owned reports/backend-test-pytest-collection-initial.md and contracts/backend-test-pytest-collection-initial.json (collection-v3) with bounded collection/fixture diagnostics, repairPaths, asset hashes, collected item IDs and deterministic repair eligibility.",
 			"allowedPaths": [
 				"testcase/**",
-				"docs/test-reports/**"
+				"docs/test-reports/**",
+				"testcase/**/test_*.py"
 			],
 			"forbiddenPaths": [
 				".harness/**",
@@ -519,7 +520,7 @@
 			],
 			"runIf": "$.nodes['assess-backend-pytest-collection-shell'].json.repairEligible == true",
 			"complexity": "MED",
-			"subtask_prompt": "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution. Treat any upstream line such as `Repair paths: testcase/test_x.py` as complete authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.\n\nInitial status REPAIRABLE means at least one listed finding remains: `already-satisfied` is forbidden, and you must produce a non-empty bounded diff on repairPaths before returning `IMPLEMENTATION_OUTCOME: changed`. Fix only readiness-proven generated testcase-local defects on initial facts repairPaths: create exact safe missing mapped test_*.py paths, repair syntax/import/symbol/decorator/parameterization, close generated fixture dependencies/plugin registration, and repair initial Markdown-to-pytest correspondence findings. Use this deterministic repair map instead of reading analyzer implementation: findings about `Case-ID`, `Assertion-Test-Points`, or `Cross-Cutting-Test-Points` are fixed by editing the declared primary symbol docstring metadata lines; variant binding findings are fixed in the literal direct `pytest.param(..., id=\"TP-...\")` row; primary-symbol cardinality/name findings are fixed in the function name or duplicate primary symbols; script mismatch is fixed only on the authoritative assessment repairPaths; payload findings are fixed in request payload construction. Do not read controller `src/**` or inspect JS/TS analyzer code. Do not search for `testcase/**/README.md`. Never invent a business pytest symbol for evidence-only Markdown Cases that declare `脚本/primary symbol=无` with empty variants. For fixture defects inspect both provider and importer listed by repairPaths; fix ScopeMismatch by aligning fixture scopes or inlining request-scoped values so module fixtures never depend on function fixtures; when a shared fixture depends on sibling fixtures, register the whole provider module through an exact pytest_plugins declaration rather than importing only the outer fixture. Do not create unrelated pytest scripts.\n\nThis is the single pytest incremental synchronization round. The `Findings` in `reports/backend-test-pytest-collection-initial.md` are the mandatory repair checklist: resolve every repairable listed finding on every authoritative `Repair paths` file before considering any other advisory evidence, and never substitute an unrelated scenario-param cleanup for a listed correspondence/collection defect. For every assessment-listed path, compare the effective Markdown Case/Test Points/test data and its `Payload Contract`/`Payload Required Paths`/`Payload Allowed Paths`/`Payload Enum` labels with the generated module. Incrementally add or repair only missing symbols, params, assertions and payload builders. Repair every assessment-listed missing nested path, unexpected key and enum mismatch; preserve exact DTO keys, nested shapes, enum/boundary literals, operation transport and business preconditions; remove guessed replacement keys only when the effective Markdown proves the exact contract. Keep path/query/header identifiers and scenario-control metadata separate from DTO patches and JSON bodies; an `id` used for a path target must be passed to the request path/helper, never inserted into a body patch unless `id` is explicitly listed in Payload Allowed Paths. Flatten every variant into a literal direct `pytest.param(..., id=\"TP-...\")` row; replace `_post_case`/`_put_case` or other parameter-row factories because correspondence and scenario readiness require the actual row values and IDs to be statically visible. Also repair helper call sites to match their defined return signatures; do not tuple-unpack a helper that returns one scalar value.\n\nPreserve final testcase/md/** semantics, every Case ID, Rule/Test Point binding, primary symbol, parameter ID, expected status/body/schema assertion, HTTP logging, redaction and truncation behavior.\n\nUse local edit only on assessment-listed paths; keep summaries short; never rewrite unrelated modules.\n\nDo not reinterpret requirements beyond the effective Markdown and bounded assessment diagnostics. Do not modify Markdown, conftest, pytest config, production code or dependencies.\n\nDo not add skip/skipif/xfail, remove tests, reduce collected items, loosen assertions, swallow exceptions, use try/except ImportError fallback, mutate sys.path/PYTHONPATH, or replace the real API with mocks.\n\nDo not execute pytest; the deterministic effective collection gate owns the final collection attempt.",
+			"subtask_prompt": "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution. The direct upstream JSON includes authoritative `repairPaths` and bounded `repairFindings`; treat both as the complete mandatory checklist without searching for a run directory or report file. Treat any upstream line such as `Repair paths: testcase/test_x.py` as equivalent authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.\n\nInitial status REPAIRABLE means at least one listed finding remains: `already-satisfied` is forbidden, and you must produce a non-empty bounded diff on repairPaths before returning `IMPLEMENTATION_OUTCOME: changed`. Fix only readiness-proven generated testcase-local defects on initial facts repairPaths: create exact safe missing mapped test_*.py paths, repair syntax/import/symbol/decorator/parameterization, close generated fixture dependencies/plugin registration, and repair initial Markdown-to-pytest correspondence findings. Use this deterministic repair map instead of reading analyzer implementation: findings about `Case-ID`, `Assertion-Test-Points`, or `Cross-Cutting-Test-Points` are fixed by editing the declared primary symbol docstring metadata lines; variant binding findings are fixed in the literal direct `pytest.param(..., id=\"TP-...\")` row; primary-symbol cardinality/name findings are fixed in the function name or duplicate primary symbols; script mismatch is fixed only on the authoritative assessment repairPaths; payload findings are fixed in request payload construction. Do not read controller `src/**` or inspect JS/TS analyzer code. Do not search for `testcase/**/README.md`. Never invent a business pytest symbol for evidence-only Markdown Cases that declare `脚本/primary symbol=无` with empty variants. For fixture defects inspect both provider and importer listed by repairPaths; fix ScopeMismatch by aligning fixture scopes or inlining request-scoped values so module fixtures never depend on function fixtures; when a shared fixture depends on sibling fixtures, register the whole provider module through an exact pytest_plugins declaration rather than importing only the outer fixture. Do not create unrelated pytest scripts.\n\nThis is the single pytest incremental synchronization round. The `Findings` in `reports/backend-test-pytest-collection-initial.md` are the mandatory repair checklist: resolve every repairable listed finding on every authoritative `Repair paths` file before considering any other advisory evidence, and never substitute an unrelated scenario-param cleanup for a listed correspondence/collection defect. For every assessment-listed path, compare the effective Markdown Case/Test Points/test data and its `Payload Contract`/`Payload Required Paths`/`Payload Allowed Paths`/`Payload Enum` labels with the generated module. Incrementally add or repair only missing symbols, params, assertions and payload builders. Repair every assessment-listed missing nested path, unexpected key and enum mismatch; preserve exact DTO keys, nested shapes, enum/boundary literals, operation transport and business preconditions; remove guessed replacement keys only when the effective Markdown proves the exact contract. Keep path/query/header identifiers and scenario-control metadata separate from DTO patches and JSON bodies; an `id` used for a path target must be passed to the request path/helper, never inserted into a body patch unless `id` is explicitly listed in Payload Allowed Paths. Flatten every variant into a literal direct `pytest.param(..., id=\"TP-...\")` row; replace `_post_case`/`_put_case` or other parameter-row factories because correspondence and scenario readiness require the actual row values and IDs to be statically visible. Also repair helper call sites to match their defined return signatures; do not tuple-unpack a helper that returns one scalar value.\n\nPreserve final testcase/md/** semantics, every Case ID, Rule/Test Point binding, primary symbol, parameter ID, expected status/body/schema assertion, HTTP logging, redaction and truncation behavior.\n\nUse local edit only on assessment-listed paths; keep summaries short; never rewrite unrelated modules.\n\nDo not reinterpret requirements beyond the effective Markdown and bounded assessment diagnostics. Do not modify Markdown, conftest, pytest config, production code or dependencies.\n\nDo not add skip/skipif/xfail, remove tests, reduce collected items, loosen assertions, swallow exceptions, use try/except ImportError fallback, mutate sys.path/PYTHONPATH, or replace the real API with mocks.\n\nDo not execute pytest; the deterministic effective collection gate owns the final collection attempt.",
 			"executor": "pi",
 			"role": "implementer",
 			"toolProfile": "write",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.40.0-next.10",
+  "version": "0.40.0-next.11",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",