@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.2

package/CHANGELOG.md

@@ -3,6 +3,10 @@
 ## [Unreleased]
 
 - Console「Pi 插件」新增升级功能：进入页面自动检查已安装插件的可用更新（从 npm 配置的仓库拉取每个已装包的 latest，与本地实际版本做语义化比较），检测到新版本时该插件行展示「升级 v<新版本>」按钮，一键升级到目标版本；工具栏提供「检查更新」手动重查入口，摘要行显示「已安装 N 个 · M 个可升级」；单包拉取失败不影响其它插件的判定，检查结果在服务端缓存 60 秒避免频繁刷新打爆 registry。
+- backend-test 新增可选 strict `backendTest.moduleLayout`：可结构化冻结模块、业务资源、operation ownership 和不同 stem 的 Markdown/Python 精确路径，归一化合同 SHA 进入 Run-owned manifest；`output-budget` 拆分必须携带版本化数值 proof，纯理由字符串不再通过。
+- 修复 backend-test Markdown 分片把同一接口的参数轴、组合、响应字段和回归类型误拆成多个物理模块的问题：Plan 现在优先保留主需求显式列出的 Markdown/Python 文件对，否则按最小稳定业务资源分组；Module Index 增加业务资源、operation/rule/Case ownership、拆分原因和精确路径，manifest 在 map 展开前拒绝测试目的型资源及无依据的同接口多模块，并可在权威合同无冲突时最多一次修复 Run-owned Plan 后再展开 map。
+- 修复 backend-test Markdown writer 已明确写出 TP 分类语义但因圆括号、方括号或 pipe 标注不符合扫描格式而连续三次高 token 重试的问题：Completeness Gate 会在当前 child writeSet 内确定性补写 canonical 变体/断言/横切标签并复验；仍为单文件纯 binding-format 缺陷时最多一次 lightweight repair，不再重放第三次 full-context writer；否定、模糊、重复和未声明分类继续 fail-closed。
+- 修复 backend-test 显式 Markdown/Python 路径使用不同 stem 时 Markdown validation 仍按 `test_<markdown-stem>.py` 推导默认脚本并误报的问题：validator 现在与 manifest/correspondence 一样读取冻结 Module Index 的 exact pytest path。
 - 修复 DAG 节点「执行过程」导出 HTML 在内网反代/子路径部署下整页样式丢失的问题：导出不再写死从主机根抓 /inspect/styles.css（反代下 404 后静默回退兜底样式，按钮与卡片样式全丢），改为直接复用页面实际加载的样式表地址（相对当前页面解析，任何部署形态都拿到同一份 CSS，多张样式表合并）；导出文档 body 补 data-shell 属性让内联页面 CSS 的设计令牌与前缀规则原生命中；兜底样式补充最小按钮样式。
 - 修复 DAG 检查器节点「执行过程」导出 HTML 在系统深色模式下黑底黑字不可读的问题：导出文档自带完整的 `:root` 颜色变量定义（页面样式变量挂在 `body[data-shell]` 选择器下、独立导出文档不生效）并强制 light 配色，深色系统打开导出文件正文对比度恢复正常（15.4:1）。
 - 修复「Pi 插件」安装时内网 Nexus 拉 scoped 包（如 `@0xkobold/pi-ollama`）版本列表失败的问题：包名整段编码不再把 `%2F` 还原成字面 `/`，与 npm 客户端请求形式一致，npmjs.org 与内网 Nexus 均正常返回。
@@ -104,6 +108,20 @@
 - 右侧辅助栏统一承载文件、上下文、调用记录、运行活动和当前 DAG；点击消息流中的运行状态即可在同一侧栏查看运行、门禁与产物，并可自由调整侧栏宽度。
 - 新增任务清单与结构化提问卡片，让长任务的进度和需要用户选择的内容更容易理解。
 - 「对话 / 操作 / 观测」使用统一导航；操作和观测页面可以切换工作区查看对应数据。
+## [0.41.0] - 2026-08-31
+
+### 新增
+
+- 新增了本发布周期内已经完成并通过验证的功能。
+
+### 改进
+
+- 完善了日常使用体验和运行稳定性。
+
+### 修复
+
+- 修复了影响使用体验或运行稳定性的问题。
+
 ## [0.40.0] - 2026-08-31
 
 ### 重点更新

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.42.0-next.1",
-  "gitSha": "fdc98f1393f69abd9a052de266f7199f580e4061",
-  "builtAt": "2026-08-31T11:04:06.136Z"
+  "version": "0.42.0-next.2",
+  "gitSha": "464c462ece3604d8b6c7b44a7a915e5465bbc84f",
+  "builtAt": "2026-08-31T12:53:12.759Z"
 }

package/dist/task/config-types.js

@@ -131,6 +131,75 @@ export const frontendTestConfigSchema = z.object({
         .strict()
         .optional(),
 });
+const backendTestBudgetProofSchema = z
+    .object({
+    groupId: z.string().min(1),
+    estimatedCaseCount: z.number().int().positive(),
+    estimatedTestPointCount: z.number().int().positive(),
+    estimatedOutputChars: z.number().int().positive(),
+    maxOutputCharsPerWriter: z.number().int().positive(),
+    estimatorVersion: z.literal("backend-test-output-estimator-v1"),
+    inputSha256: z.string().regex(/^[a-f0-9]{64}$/),
+})
+    .strict();
+const backendTestModuleLayoutEntrySchema = z
+    .object({
+    stem: z.string().regex(/^[a-z][a-z0-9_]*$/),
+    businessResource: z.string().min(1),
+    markdownPath: z.string().min(1),
+    pytestPath: z.string().min(1),
+    ownedOperations: z.array(z.string().regex(/^(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS) \/\S+$/)).min(1),
+    splitReason: z.enum([
+        "explicit-user-layout",
+        "primary-business-resource",
+        "independent-business-resource",
+        "output-budget",
+    ]),
+    budgetProof: backendTestBudgetProofSchema.optional(),
+})
+    .strict()
+    .superRefine((entry, ctx) => {
+    const safe = (value) => !value.startsWith("/") &&
+        !value.startsWith("\\") &&
+        !value.includes("..") &&
+        !value.includes("\\");
+    if (!safe(entry.markdownPath) || !entry.markdownPath.endsWith(".md")) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["markdownPath"], message: "must be a safe repository-relative .md path" });
+    }
+    if (!safe(entry.pytestPath) || !entry.pytestPath.endsWith(".py")) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["pytestPath"], message: "must be a safe repository-relative .py path" });
+    }
+    if (entry.splitReason === "output-budget" && !entry.budgetProof) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["budgetProof"], message: "is required for output-budget split" });
+    }
+    if (entry.splitReason !== "output-budget" && entry.budgetProof) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["budgetProof"], message: "is only valid for output-budget split" });
+    }
+});
+const backendTestModuleLayoutSchema = z
+    .object({
+    schemaId: z.literal("backend-test-module-layout-v1"),
+    mode: z.enum(["explicit-file-layout", "business-resource-layout"]),
+    modules: z.array(backendTestModuleLayoutEntrySchema).min(1).max(8),
+})
+    .strict()
+    .superRefine((layout, ctx) => {
+    for (const key of ["stem", "markdownPath", "pytestPath"]) {
+        const seen = new Set();
+        for (let index = 0; index < layout.modules.length; index += 1) {
+            const value = layout.modules[index][key];
+            if (seen.has(value))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["modules", index, key], message: `duplicate ${key}` });
+            seen.add(value);
+        }
+    }
+    if (layout.mode === "explicit-file-layout") {
+        layout.modules.forEach((entry, index) => {
+            if (entry.splitReason !== "explicit-user-layout")
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["modules", index, "splitReason"], message: "explicit-file-layout requires explicit-user-layout" });
+        });
+    }
+});
 /** Backend-test artifact layout and pipeline mode configuration (plan A/B/D). */
 export const backendTestConfigSchema = z
     .object({
@@ -152,6 +221,8 @@ export const backendTestConfigSchema = z
     workspaceControl: z.enum(["git", "filesystem-only"]).optional(),
     /** Per-command timeout for the readiness-authorized pytest/HTML execution node. */
     executeTimeoutMs: z.number().int().min(60_000).max(7_200_000).optional(),
+    /** Optional strict physical/business module layout; authoritative over model-derived layout. */
+    moduleLayout: backendTestModuleLayoutSchema.optional(),
 })
     .strict()
     .optional();

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

@@ -668,6 +668,92 @@ function automationLabelBody(body, labels) {
     const match = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:]\\s*(.*)$`, "mi").exec(automation);
     return match?.[1]?.replaceAll("`", "").trim() ?? "";
 }
+const BINDING_NEGATION_OR_AMBIGUITY = /(?:不是|并非|非变体|非断言|非横切|可能|待定|或者|\b(?:TBD|unknown)\b)/i;
+function explicitBindingModeFromLine(line) {
+    if (BINDING_NEGATION_OR_AMBIGUITY.test(line))
+        return undefined;
+    const modes = TEST_POINT_BINDING_MODES.filter((mode) => AUTOMATION_BINDING_LABELS[mode].some((label) => line.includes(label)));
+    return modes.length === 1 ? modes[0] : undefined;
+}
+/**
+ * Canonicalize only explicit, unambiguous Test Point classification marks.
+ * The model occasionally writes `TP-X（变体测试点）`, `[场景断言测试点] TP-X`
+ * or a pipe-delimited equivalent. Those forms carry deterministic semantics,
+ * but are not the machine contract consumed by automationLabelBody(). Keep the
+ * original prose and materialize the same binding under `### 自动化映射` as the
+ * canonical single-line labels. Never infer a mode from ordinary prose.
+ */
+export function canonicalizeBackendTestMarkdownTestPointBindings(markdown) {
+    const headings = [...markdown.matchAll(CASE_HEADING)];
+    let output = "";
+    let cursor = 0;
+    const unsafeTestPoints = [];
+    const canonicalizedTestPoints = [];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        const start = heading.index;
+        const end = headings[index + 1]?.index ?? markdown.length;
+        const body = markdown.slice(start, end);
+        output += markdown.slice(cursor, start);
+        cursor = end;
+        const declared = listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT);
+        const current = testPointBindingFacts(body, declared);
+        const currentByMode = new Map(TEST_POINT_BINDING_MODES.map((mode) => [
+            mode,
+            current.testPointBindings.filter((item) => item.mode === mode).map((item) => item.testPoint),
+        ]));
+        const unresolved = new Set(current.unclassifiedTestPoints);
+        for (const line of body.split(/\r?\n/)) {
+            const mode = explicitBindingModeFromLine(line);
+            if (!mode)
+                continue;
+            const tokens = orderedUnique(line.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
+            for (const token of tokens) {
+                if (!unresolved.has(token))
+                    continue;
+                const existingModes = TEST_POINT_BINDING_MODES.filter((candidate) => (currentByMode.get(candidate) ?? []).includes(token));
+                if (existingModes.length > 0)
+                    continue;
+                currentByMode.set(mode, orderedUnique([...(currentByMode.get(mode) ?? []), token]));
+                unresolved.delete(token);
+                canonicalizedTestPoints.push(token);
+            }
+        }
+        unsafeTestPoints.push(...unresolved);
+        if (unresolved.size === current.unclassifiedTestPoints.length) {
+            output += body;
+            continue;
+        }
+        const automationMarker = /^###\s+(?:自动化映射|Automation Mapping)\s*$/mi.exec(body);
+        if (!automationMarker) {
+            output += body;
+            continue;
+        }
+        const automationStart = automationMarker.index + automationMarker[0].length;
+        const rest = body.slice(automationStart);
+        const nextSection = /^###\s+/m.exec(rest);
+        const automationEnd = automationStart + (nextSection?.index ?? rest.length);
+        let automation = body.slice(automationStart, automationEnd);
+        for (const mode of TEST_POINT_BINDING_MODES) {
+            const labels = AUTOMATION_BINDING_LABELS[mode];
+            const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+            const canonicalLine = `- ${AUTOMATION_BINDING_LABELS[mode][0]}：${(currentByMode.get(mode) ?? []).join("; ") || "无"}`;
+            const linePattern = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:].*$`, "mi");
+            if (linePattern.test(automation))
+                automation = automation.replace(linePattern, canonicalLine);
+            else
+                automation = `${automation.replace(/\s*$/, "")}\n${canonicalLine}\n`;
+        }
+        output += body.slice(0, automationStart) + automation + body.slice(automationEnd);
+    }
+    output += markdown.slice(cursor);
+    return {
+        markdown: output,
+        changed: output !== markdown,
+        unsafeTestPoints: orderedUnique(unsafeTestPoints),
+        canonicalizedTestPoints: orderedUnique(canonicalizedTestPoints),
+    };
+}
 export function inspectBackendTestMarkdownTestPointBindings(markdown) {
     const headings = [...markdown.matchAll(CASE_HEADING)];
     return headings.map((heading, index) => {
@@ -1312,8 +1398,16 @@ export async function analyzeBackendTestCaseCoverage(input) {
 function normalizeModuleStem(markdownPath) {
     return path.posix.basename(markdownPath).replace(/\.md$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
-function expectedScript(markdownPath, layout) {
+function expectedScript(markdownPath, layout, declaredScripts = []) {
     const resolved = layout ?? resolveBackendTestLayout(undefined);
+    if (declaredScripts.length === 1) {
+        const candidate = declaredScripts[0].replaceAll("\\", "/").replace(/^\.\//, "");
+        const prefix = resolved.scriptDir === "." ? "" : `${resolved.scriptDir}/`;
+        const relative = prefix && candidate.startsWith(prefix) ? candidate.slice(prefix.length) : candidate;
+        if ((!prefix || candidate.startsWith(prefix)) && !relative.includes("..") && /^test_[A-Za-z0-9_.-]+\.py$/.test(path.posix.basename(candidate))) {
+            return candidate;
+        }
+    }
     return `${resolved.scriptDir}/test_${normalizeModuleStem(markdownPath)}.py`;
 }
 function symbolCaseId(symbol) {
@@ -1863,7 +1957,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const layout = input.layout ?? resolveBackendTestLayout(undefined);
     const cases = await parseMarkdownCases(input.workspaceRoot, layout);
     const modulePaths = orderedUnique(cases.map((item) => item.markdownPath));
-    const scripts = orderedUnique(cases.flatMap((item) => [...item.declaredScripts, expectedScript(item.markdownPath, layout)]));
+    const scripts = orderedUnique(cases.flatMap((item) => [expectedScript(item.markdownPath, layout, item.declaredScripts)]));
     const allSymbols = [];
     const scriptFiles = [];
     for (const script of scripts) {
@@ -1876,7 +1970,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const findings = [];
     const entries = [];
     for (const testCase of cases) {
-        const expected = expectedScript(testCase.markdownPath, layout);
+        const expected = expectedScript(testCase.markdownPath, layout, testCase.declaredScripts);
         const declared = testCase.declaredScripts[0];
         const refs = allSymbols.filter((item) => item.caseIds.includes(testCase.caseId));
         const actualScripts = orderedUnique(refs.map((item) => item.script));
@@ -2034,8 +2128,9 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     for (const [signature, owners] of duplicateSignatureGroups)
         findings.push(`duplicate execution signature ${signature}: ${orderedUnique(owners).join(", ")}`);
     const exactModuleCount = modulePaths.filter((modulePath) => {
-        const expected = expectedScript(modulePath, layout);
         const moduleCases = cases.filter((item) => item.markdownPath === modulePath);
+        const moduleDeclaredScripts = orderedUnique(moduleCases.flatMap((item) => item.declaredScripts));
+        const expected = expectedScript(modulePath, layout, moduleDeclaredScripts);
         return moduleCases.every((item) => item.declaredScripts.length === 1 && item.declaredScripts[0] === expected) && scriptFiles.some((file) => path.relative(input.workspaceRoot, file).replaceAll(path.sep, "/") === expected);
     }).length;
     const caseEntries = entries.filter((entry) => entry.cardinality !== "0:1");

package/dist/workflows/dag/backend-test-markdown-workflow.js

@@ -285,6 +285,7 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         moduleIndexHeadingCount,
         declaredStems: [],
         declaredMdFiles: [],
+        declaredScriptByMarkdown: {},
         declaredMissing: [],
         unmanifested: [],
     });
@@ -306,6 +307,15 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         return invalid("duplicate", moduleIndexHeadingCount);
     }
     const declaredStems = extractDeclaredModuleIndexFilenames(readme);
+    const declaredScriptByMarkdown = {};
+    const mdPrefix = escapeRegExp(`${resolved.markdownDir}/`);
+    const scriptPrefix = escapeRegExp(`${resolved.scriptDir}/`);
+    for (const line of readme.split(/\r?\n/)) {
+        const markdown = new RegExp(`(${mdPrefix}[A-Za-z0-9_.-]+\\.md)`).exec(line)?.[1];
+        const pytest = new RegExp(`(${scriptPrefix}[A-Za-z0-9_./-]+\\.py)`).exec(line)?.[1];
+        if (markdown && pytest)
+            declaredScriptByMarkdown[markdown] = pytest;
+    }
     if (declaredStems.length === 0) {
         return invalid("empty-unparsable", moduleIndexHeadingCount);
     }
@@ -345,6 +355,7 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         moduleIndexHeadingCount,
         declaredStems,
         declaredMdFiles: declaredMdFiles.sort(),
+        declaredScriptByMarkdown,
         declaredMissing: declaredMissing.sort(),
         unmanifested: unmanifested.sort(),
     };
@@ -694,7 +705,8 @@ export async function validateBackendMarkdownCases(input) {
             if (!hasAssertableExpectedResult(expected)) {
                 findings.push(`${testCase.id} has no structured expected result`);
             }
-            const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
+            const expectedScript = manifest.declaredScriptByMarkdown[relativeFile] ??
+                expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
             const mappedScripts = extractMappedPytestScripts(testCase.body);
             if (isEvidenceOnlyMarkdownCaseBody(testCase.body)) {
                 // Evidence-only meta cases intentionally declare 脚本/primary symbol as 无 and keep only assertion/cross-cutting TPs.

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

@@ -4,7 +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";
+import { canonicalizeBackendTestMarkdownTestPointBindings, 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.
@@ -47,8 +47,16 @@ const progressSchema = z
         path: z.string().optional(),
         detail: z.string(),
         recoverable: z.boolean(),
+        failureSubreason: z.literal("markdown-test-point-binding-format").optional(),
+        affectedCases: z.array(z.string()).optional(),
+        testPointIds: z.array(z.string()).optional(),
+        canonicalizationEligible: z.boolean().optional(),
+        canonicalizationOutcome: z.enum(["not-attempted", "changed", "already-canonical", "unsafe", "revalidation-failed"]).optional(),
     })
         .strict()),
+    canonicalizationOutcome: z.enum(["not-attempted", "changed", "already-canonical", "unsafe", "revalidation-failed"]).optional(),
+    canonicalizedTestPointCount: z.number().int().min(0).optional(),
+    lightweightRepairEligible: z.boolean().optional(),
 })
     .strict();
 async function exists(filePath) {
@@ -520,6 +528,9 @@ export async function assessBackendTestShardChildCompleteness(input) {
     const actualPaths = [];
     const missingPaths = [];
     const brokenPaths = [];
+    let canonicalizationOutcome = role === "md-generate" ? "already-canonical" : undefined;
+    let canonicalizedTestPointCount = 0;
+    let lightweightRepairEligible = false;
     for (const target of targetPaths) {
         // Rendered map-child writeSet entries are concrete (e.g.
         // testcase/md/health.md / testcase/test_orders.py); glob-only entries are
@@ -538,16 +549,44 @@ export async function assessBackendTestShardChildCompleteness(input) {
             continue;
         }
         actualPaths.push(target);
-        const body = await readFile(absolute, "utf8");
+        let body = await readFile(absolute, "utf8");
         if (role === "md-generate") {
+            const beforeBindings = inspectBackendTestMarkdownTestPointBindings(body);
+            const canonicalization = canonicalizeBackendTestMarkdownTestPointBindings(body);
+            if (canonicalization.changed) {
+                await writeFile(absolute, canonicalization.markdown, "utf8");
+                body = canonicalization.markdown;
+                canonicalizationOutcome = "changed";
+                canonicalizedTestPointCount += canonicalization.canonicalizedTestPoints.length;
+            }
+            const afterBindings = inspectBackendTestMarkdownTestPointBindings(body);
+            const unresolved = afterBindings.flatMap((entry) => entry.unclassifiedTestPoints);
+            const bindingCases = afterBindings
+                .filter((entry) => entry.unclassifiedTestPoints.length > 0 || entry.duplicateBindingTestPoints.length > 0)
+                .map((entry) => entry.caseId);
             const structural = moduleStructurallyComplete(body);
             if (!structural.ok) {
+                lightweightRepairEligible = bindingCases.length > 0;
+                if (bindingCases.length > 0)
+                    canonicalizationOutcome = canonicalization.changed ? "revalidation-failed" : "unsafe";
                 brokenPaths.push(target);
+                const bindingFormatIssue = bindingCases.length > 0;
                 issues.push({
                     code: "T5",
                     path: target,
                     detail: moduleStructuralDetail(structural),
                     recoverable: true,
+                    ...(bindingFormatIssue
+                        ? {
+                            failureSubreason: "markdown-test-point-binding-format",
+                            affectedCases: orderedUnique(bindingCases),
+                            testPointIds: orderedUnique(unresolved),
+                            canonicalizationEligible: canonicalization.canonicalizedTestPoints.length > 0,
+                            canonicalizationOutcome: canonicalization.changed
+                                ? (unresolved.length === 0 ? "changed" : "revalidation-failed")
+                                : (beforeBindings.some((entry) => entry.unclassifiedTestPoints.length > 0) ? "unsafe" : "already-canonical"),
+                        }
+                        : {}),
                 });
             }
         }
@@ -586,6 +625,9 @@ export async function assessBackendTestShardChildCompleteness(input) {
         brokenPaths: orderedUnique(brokenPaths),
         targetPaths: recoverableTargets,
         issues,
+        ...(role === "md-generate"
+            ? { canonicalizationOutcome, canonicalizedTestPointCount, lightweightRepairEligible }
+            : {}),
     };
 }
 export async function assessBackendTestMdWriterCompleteness(workspaceRoot, layout) {
@@ -853,7 +895,7 @@ export async function writeBackendTestWriterProgressArtifacts(input) {
         "## Issues",
         "",
         ...(input.progress.issues.length
-            ? input.progress.issues.map((issue) => `- [${issue.code}] ${issue.path ?? "(workspace)"}: ${issue.detail}`)
+            ? input.progress.issues.map((issue) => `- [${issue.code}] ${issue.path ?? "(workspace)"}: ${issue.detail}${issue.failureSubreason ? `; failureSubreason=${issue.failureSubreason}; canonicalizationOutcome=${issue.canonicalizationOutcome ?? "not-attempted"}; canonicalizationEligible=${issue.canonicalizationEligible ?? false}; affectedCases=${(issue.affectedCases ?? []).join(",") || "none"}; testPointIds=${(issue.testPointIds ?? []).join(",") || "none"}` : ""}`)
             : ["- None"]),
         "",
         `<!-- sha256:${createHash("sha256").update(JSON.stringify(parsed)).digest("hex")} -->`,

package/dist/workflows/dag/init-hybrid.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { access, readdir, readFile, realpath } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
+import { deflateRawSync } from "node:zlib";
 import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertValidDagSpec } from "./validate.js";
@@ -11,7 +12,7 @@ import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { extractTaskSourceOpenspecPaths } from "../../shared/openspec-spec.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
-import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PLANNER_OUTPUT_LIMIT_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRUCTURED_REQUIRED_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY, isCanonicalFinalVerifyShellRetryCandidate, isSafeReadOnlyPiRetryCandidate, isTargetTemplateImplementPi, isWriterTransportRetryCandidate, } from "./retry-policy.js";
+import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PLANNER_OUTPUT_LIMIT_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRUCTURED_REQUIRED_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, BACKEND_TEST_MARKDOWN_BINDING_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY, isCanonicalFinalVerifyShellRetryCandidate, isSafeReadOnlyPiRetryCandidate, isTargetTemplateImplementPi, isWriterTransportRetryCandidate, } from "./retry-policy.js";
 import { REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL, REVIEW_VERDICT_OUTPUT_PROTOCOL, } from "./output-protocol.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
@@ -4017,7 +4018,7 @@ export function applyBackendTestLayoutToText(text, layout) {
  * normalization. Output is exactly one trailing JSON line `{modules:[{stem}]}`
  * that `parseJsonFromText` accepts after shell command echoes.
  */
-function buildBackendTestModuleManifestShellCommand(layout) {
+function buildBackendTestModuleManifestShellCommand(layout, moduleLayout) {
     // The extractor is base64-encoded so the shell command is fully opaque to
     // bash: no backticks (command substitution), no regex \/ escaping, no
     // backslash-counting through TS-string -> JSON.stringify -> bash -c -> node -e.
@@ -4026,18 +4027,31 @@ function buildBackendTestModuleManifestShellCommand(layout) {
     // mdDir/testPrefix are injected as JSON literals so the same extractor
     // works for any configured backendTest layout (plan A).
     const mdDirLiteral = JSON.stringify(layout.markdownDir);
+    const scriptDirLiteral = JSON.stringify(layout.scriptDir);
+    const strictLayoutCompressed = moduleLayout
+        ? deflateRawSync(Buffer.from(JSON.stringify(moduleLayout), "utf8")).toString("base64")
+        : null;
+    const strictLayoutExpression = strictLayoutCompressed
+        ? `JSON.parse(zlib.inflateRawSync(Buffer.from(${JSON.stringify(strictLayoutCompressed)},'base64')).toString('utf8'))`
+        : "null";
+    const strictLayoutShaLiteral = JSON.stringify(moduleLayout
+        ? createHash("sha256").update(JSON.stringify(moduleLayout)).digest("hex")
+        : null);
     const escOpen = String.fromCharCode(92, 91); // \[
     const escClose = String.fromCharCode(92, 93); // \]
     const escBslash = String.fromCharCode(92, 92); // \\
-    const script = `const fs=require('fs'),path=require('path'),crypto=require('crypto');
+    const script = `const fs=require('fs'),path=require('path'),crypto=require('crypto'),zlib=require('zlib');
 const mdDir=${mdDirLiteral};
+const scriptDir=${scriptDirLiteral};
+const strictLayout=${strictLayoutExpression};
+const strictLayoutSha256=${strictLayoutShaLiteral};
 const esc=s=>s.replace(/[${escOpen}${escClose}{}()*+?^$|${escBslash}]/g,'${escBslash}$&');
 const rxMdPath=new RegExp(esc(mdDir)+'${escBslash}/([A-Za-z0-9_.-]+)${escBslash}.md','g');
 const runDir=process.env.HARNESS_DAG_RUN_DIR||'';
 if(!runDir){process.stderr.write('missing HARNESS_DAG_RUN_DIR for backend-test Markdown plan artifact\\n');process.exit(2);}
 const planPath=path.join(runDir,'generate-backend-md-plan-pi','plan.md');
 if(!fs.existsSync(planPath)){process.stderr.write('missing backend-test Markdown plan artifact: '+planPath+'\\n');process.exit(2);}
-const readme=fs.readFileSync(planPath,'utf8');
+let readme=fs.readFileSync(planPath,'utf8');
 const norm=s=>String(s).toLowerCase().replace(/[^a-z0-9]+/g,'_').replace(/^_+|_+$/g,'').replace(/_+/g,'_');
 const bt=String.fromCharCode(96);
 const stripBackticks=s=>s.split(bt).join('');
@@ -4051,23 +4065,68 @@ const start=headings[0]+1;let end=allLines.length;for(let i=start;i<allLines.len
 const section=allLines.slice(start,end).join('\\n');
 const raw=[];
 const lines=section.split('\\n').filter(l=>l.includes('|'));
-for(const line of lines){
-  const bare=stripBackticks(line);
-  for(const m of bare.matchAll(rxMdPath)){raw.push(m[1]);}
+const cells=line=>line.split('|').slice(1,-1).map(value=>stripBackticks(value).trim());
+const expectedHeader=['Module Stem','Business Resource','Owned Operations','Owned Rule Keys','Case IDs','Split Reason','Markdown Path','Pytest Path'];
+const headerIndex=lines.findIndex(line=>{const row=cells(line);return expectedHeader.every((value,index)=>row[index]===value);});
+if(headerIndex<0){process.stderr.write('invalid-module-index-header: require exact business ownership and path columns\\n');process.exit(2);}
+const dataRows=lines.slice(headerIndex+2).map(cells).filter(row=>row.length>=8&&row[0]&&row[0]!=='Module Stem');
+const allowedSplit=new Set(['explicit-user-layout','primary-business-resource','independent-business-resource','output-budget']);
+const strictExpectedStems=new Set((strictLayout&&strictLayout.modules||[]).map(item=>item.stem));
+const operationOwners=new Map();const declaredModules=[];let planRepairApplied=false;
+for(const row of dataRows){
+  const stem=norm(row[0]),resource=String(row[1]||'').trim(),operations=String(row[2]||'').split(';').map(value=>value.trim()).filter(Boolean),split=String(row[5]||'').trim();
+  if(strictLayout&&!strictExpectedStems.has(stem)){planRepairApplied=true;continue;}
+  if(!resource){process.stderr.write('missing-business-resource: '+stem+'\\n');process.exit(2);}
+  if(/^(?:response|resp|regression|positive|negative|boundary|error|combo|filter)(?:[_ -]|$)/i.test(resource)){process.stderr.write('test-purpose-business-resource: '+stem+' -> '+resource+'\\n');process.exit(2);}
+  if(!allowedSplit.has(split)){process.stderr.write('invalid-module-split-reason: '+stem+' -> '+split+'\\n');process.exit(2);}
+  if(operations.length===0){process.stderr.write('missing-owned-operation: '+stem+'\\n');process.exit(2);}
+  const mdMatches=[...String(row[6]||'').matchAll(rxMdPath)];let markdownPath=mdMatches[0]&&mdMatches[0][0];
+  let pytestPath=String(row[7]||'').replace(/^\\.\\//,'').replace(/\\\\/g,'/');
+  if(mdMatches.length!==1||norm(mdMatches[0][1])!==stem){process.stderr.write('module-markdown-path-mismatch: '+stem+'\\n');process.exit(2);}
+  if(!/^[A-Za-z0-9_./-]+\\.py$/.test(pytestPath)||pytestPath.includes('..')){process.stderr.write('invalid-module-pytest-path: '+stem+' -> '+pytestPath+'\\n');process.exit(2);}
+  const required=strictLayout&&strictLayout.modules.find(item=>item.stem===stem);
+  if(required){
+    if(!required.markdownPath.startsWith(mdDir+'/')||!required.pytestPath.startsWith(scriptDir+'/')||required.markdownPath.includes('..')||required.pytestPath.includes('..')){process.stderr.write('MODULE_LAYOUT_CONFLICT: strict paths outside frozen roots for '+stem+'\\n');process.exit(2);}
+    if(markdownPath!==required.markdownPath||pytestPath!==required.pytestPath||resource!==required.businessResource||JSON.stringify(operations)!==JSON.stringify(required.ownedOperations)||split!==required.splitReason){planRepairApplied=true;}
+    markdownPath=required.markdownPath;pytestPath=required.pytestPath;
+    if(required.splitReason==='output-budget'){
+      const proof=required.budgetProof;const peers=strictLayout.modules.filter(item=>item.budgetProof&&item.budgetProof.groupId===proof.groupId);
+      if(!proof||proof.estimatedOutputChars<=proof.maxOutputCharsPerWriter||Math.ceil(proof.estimatedOutputChars/Math.max(1,peers.length))>proof.maxOutputCharsPerWriter||peers.some(item=>item.budgetProof.inputSha256!==proof.inputSha256||item.budgetProof.estimatorVersion!==proof.estimatorVersion)){process.stderr.write('INVALID_OUTPUT_BUDGET_PROOF: '+stem+'\\n');process.exit(2);}
+    }
+  }
+  const item={stem,markdownPath,pytestPath,businessResource:required?required.businessResource:resource,ownedOperations:required?required.ownedOperations:operations,ownedRuleKeys:String(row[3]||'').split(';').map(value=>value.trim()).filter(Boolean),caseIds:String(row[4]||'').split(';').map(value=>value.trim()).filter(Boolean),splitReason:required?required.splitReason:split,...(required&&required.budgetProof?{budgetProof:required.budgetProof}:{})};
+  declaredModules.push(item);
+  for(const operation of item.ownedOperations){const owners=operationOwners.get(operation)||[];owners.push({stem,split:item.splitReason});operationOwners.set(operation,owners);}
+}
+if(strictLayout){
+  const missing=strictLayout.modules.filter(item=>!declaredModules.some(actual=>actual.stem===item.stem));
+  if(missing.length){process.stderr.write('MODULE_LAYOUT_CONFLICT: plan missing required modules '+missing.map(item=>item.stem).join(',')+'; deterministic Plan-only repair cannot invent Rule/Case ownership\\n');process.exit(2);}
+  if(planRepairApplied){
+    const table=['| '+expectedHeader.join(' | ')+' |','|'+expectedHeader.map(()=>'---').join('|')+'|',...declaredModules.map(item=>'| '+[item.stem,item.businessResource,item.ownedOperations.join('; '),item.ownedRuleKeys.join('; '),item.caseIds.join('; '),item.splitReason,'['+item.stem+'](./'+item.stem+'.md) '+item.markdownPath,item.pytestPath].join(' | ')+' |')].join('\\n');
+    readme=[...allLines.slice(0,headings[0]+1),table,...allLines.slice(end)].join('\\n');
+    fs.writeFileSync(planPath,readme,'utf8');
+  }
+}
+for(const [operation,owners] of operationOwners){if(owners.length>1&&!owners.every(owner=>owner.split==='explicit-user-layout'||owner.split==='output-budget')){process.stderr.write('overlapping-operation-modules: '+operation+' -> '+owners.map(owner=>owner.stem).join(',')+'; merge by business resource or use an authoritative explicit-user-layout\\n');process.exit(2);}}
+if(!strictLayout){
+  for(const line of lines){
+    const bare=stripBackticks(line);
+    for(const m of bare.matchAll(rxMdPath)){raw.push(m[1]);}
+  }
+  for(const m of section.matchAll(rxRelLink)){raw.push(m[1]);}
 }
-for(const m of section.matchAll(rxRelLink)){raw.push(m[1]);}
 const invalid=[];for(const r of raw){const reason=invalidReason(r);if(reason)invalid.push({stem:norm(r),reason});}
 if(invalid.length){for(const item of invalid)process.stderr.write(item.reason+': '+item.stem+'; use a stable business resource/domain stem\\n');process.exit(2);}
 const seen=new Set();const modules=[];
-for(const r of raw){const st=norm(r);if(valid(r)&&!seen.has(st)){seen.add(st);modules.push({stem:st});}}
+for(const item of declaredModules){if(valid(item.stem)&&!seen.has(item.stem)){seen.add(item.stem);modules.push(item);}}
 if(modules.length===0){process.stderr.write('empty-module-index: require at least one stable business module\\n');process.exit(2);}
 if(modules.length>8){process.stderr.write('excessive-module-count: '+modules.length+' > 8; merge by the smallest stable business resource/domain set\\n');process.exit(2);}
 const planReadPath=path.relative(process.cwd(),planPath).split(path.sep).join('/');
 const planSha256=crypto.createHash('sha256').update(readme).digest('hex');
-process.stdout.write(JSON.stringify({modules:modules.map(item=>({...item,planReadPath})),planReadPath,planSha256}));
+process.stdout.write(JSON.stringify({modules:modules.map(item=>({...item,planReadPath})),planReadPath,planSha256,moduleLayout:{schemaId:'backend-test-module-layout-facts-v1',source:strictLayout?'task-contract':'plan-derived',contractSha256:strictLayoutSha256,mode:strictLayout&&strictLayout.mode||'business-resource-layout',planRepairAttemptCount:planRepairApplied?1:0,planRepairOutcome:planRepairApplied?'changed':'not-required'}}));
 `;
-    const encoded = Buffer.from(script, "utf8").toString("base64");
-    return `node -e "eval(Buffer.from('${encoded}','base64').toString('utf8'))"`;
+    const encoded = deflateRawSync(Buffer.from(script, "utf8")).toString("base64");
+    return `node -e "eval(require('zlib').inflateRawSync(Buffer.from('${encoded}','base64')).toString('utf8'))"`;
 }
 const BACKEND_TEST_SKILLS_BY_ROLE = {
     planner: ["loop-agent"],
@@ -4655,7 +4714,14 @@ async function buildBackendTestHybridDag(sources) {
             "Each Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.",
             "Coverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.",
             "For uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.",
-            "Mandatory module index: include a `## Module Index` table in the plan artifact that lists every planned module as a canonical relative link of the exact form `[label](./<stem>.md)` plus a `testcase/md/<stem>.md` path cell, so a downstream deterministic manifest can parse the module list. Group by stable business resource/domain, not by CRUD operation: one resource's list/detail/create/update/delete cases belong in one module such as `resource_notes`; split only when a single module would exceed the per-child 16K output protocol, keep the total module count at the smallest safe value, and never exceed 8 modules. Name each module file with a stable lowercase business stem such as `health` or `resource_notes`. Pure hexadecimal/hash-like opaque stems such as `a401606` or `deadbeef` are forbidden. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix and never defines module files. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. The relative link target MUST equal the on-disk filename stem the sharded writer will create. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
+            "Mandatory module layout contract: first inspect the PRIMARY requirement for an explicit list of required Markdown/Python output path pairs. When explicit paths are present, they are authoritative `explicit-user-layout`: reproduce their exact filenames, count and one-to-one pairs in Module Index; do not rename, merge, split, omit or add a module from reference/example scripts. Only when the primary requirement has no explicit file layout may you derive the smallest `business-resource-layout`. Existing examples, historical regression functions and shared setup may add evidence/assertions to an existing required module, but never create an extra physical module by themselves. A reference-only `resp_regression`, positive/negative/boundary/error/response module is forbidden.",
+            ...(taskConfig.backendTest?.moduleLayout
+                ? [
+                    "A strict task-contract `backendTest.moduleLayout` is bound and is authoritative over model-derived layout. Reproduce every stem, businessResource, ownedOperations, splitReason, markdownPath and pytestPath exactly; do not add, omit, rename or reorder physical modules. The downstream preflight compares exact path sets and may perform at most one deterministic Plan-only pruning/path normalization; it cannot invent missing Rule/Case ownership.",
+                    `STRICT_BACKEND_TEST_MODULE_LAYOUT=${JSON.stringify(taskConfig.backendTest.moduleLayout)}`,
+                ]
+                : []),
+            "Include exactly one `## Module Index` table with this exact header: `| Module Stem | Business Resource | Owned Operations | Owned Rule Keys | Case IDs | Split Reason | Markdown Path | Pytest Path |`. Use canonical relative links `[label](./<stem>.md)` inside the Markdown Path cell followed by the resolved `${layout.markdownDir}/<stem>.md` path. Split Reason is exactly one of `explicit-user-layout`, `primary-business-resource`, `independent-business-resource`, or `output-budget`. Group by stable business resource/domain, not by CRUD operation, AC, parameter/field axis, scenario type or regression purpose: one resource's list/detail/create/update/delete and its filters/response assertions/regression floor belong in one module. Multiple modules owning the same exact `METHOD /path` are forbidden unless every such row is `explicit-user-layout` from primary-requirement path pairs or has a documented `output-budget` proof. Keep the total module count at the smallest safe value and never exceed 8 modules. Name model-derived modules with stable lowercase business stems such as `health` or `resource_notes`; explicit-user-layout preserves the primary requirement filename stem even when it is more specific. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix. Pure hexadecimal/hash-like opaque stems and test-purpose-only stems are forbidden. Do not use Case-ID-like module filenames. The relative link target, Markdown Path, Pytest Path and downstream automation mapping must be one-to-one and exact; for model-derived modules the default pair remains `testcase/md/<module>.md` and `testcase/test_<module>.py`, while explicit-user-layout preserves the primary requirement paths. Do not hand-write a conflicting module count in prose; the Module Index row count is the only count truth.",
             "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional. Before returning, expand every declared partition into its complete deterministic exact slot ID set: one `TP-<Partition ID>-<VALUE-TOKEN>` per Domain value, `TP-<Partition ID>-OMITTED` only for an optional axis, and exactly one `TP-<Partition ID>-NOT-IN-SET`. Every expanded slot ID must appear verbatim in the binding Rule's `Required Test Points` cell and be assigned to concrete Case IDs in that same Coverage Matrix row; ordinary alias/family Test Points do not replace this inventory. Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
             "Before finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
@@ -4675,10 +4741,10 @@ async function buildBackendTestHybridDag(sources) {
         writePolicy: "read-only",
         allowedPaths: ro,
         forbiddenPaths: forbidden,
-        outputContract: "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256} parsed from the run-owned generate-backend-md-plan-pi/plan.md artifact using the same module-stem extractor as the Completeness Gate.",
-        subtask_prompt: "Parse only $HARNESS_DAG_RUN_DIR/generate-backend-md-plan-pi/plan.md and emit exactly one trailing JSON line {modules:[{stem,planReadPath}],planReadPath,planSha256}. No file writes and no testcase/md/README.md fallback.",
+        outputContract: "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256,moduleLayout} parsed from the run-owned generate-backend-md-plan-pi/plan.md artifact after strict-layout validation and at most one deterministic Plan-only repair.",
+        subtask_prompt: "Parse only $HARNESS_DAG_RUN_DIR/generate-backend-md-plan-pi/plan.md, validate the optional strict module layout and output-budget proof, apply at most one deterministic Plan-only Module Index repair without project writes, then emit one JSON line. No testcase/md/README.md fallback.",
         shell: {
-            commands: [buildBackendTestModuleManifestShellCommand(layout)],
+            commands: [buildBackendTestModuleManifestShellCommand(layout, taskConfig.backendTest?.moduleLayout)],
             cwd: ".",
             timeoutMs: 60000,
         },
@@ -4714,9 +4780,9 @@ async function buildBackendTestHybridDag(sources) {
                 toolProfile: "write",
                 complexity: "MED",
                 writePolicy: "exclusive",
-                allowedPaths: ["testcase/md/{{item.stem}}.md"],
+                allowedPaths: ["{{item.markdownPath}}"],
                 forbiddenPaths: forbidden,
-                writeSet: ["testcase/md/{{item.stem}}.md"],
+                writeSet: ["{{item.markdownPath}}"],
                 readSet: [
                     "{{item.planReadPath}}",
                     toDagSourcePath(sources, sources.requirementPath),
@@ -4724,21 +4790,22 @@ async function buildBackendTestHybridDag(sources) {
                         ? [toDagSourcePath(sources, sources.constraintPath)]
                         : []),
                     ...intake.referenceIndex.map((entry) => entry.readPath),
-                    `${layout.markdownDir}/{{item.stem}}.md`,
+                    "{{item.markdownPath}}",
                 ],
                 writerOutcomePolicy: {
                     type: "implementation-outcome-v1",
                     requireChangedFiles: true,
                 },
-                retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
-                outputContract: "Write exactly one Chinese module Markdown case-card file testcase/md/<stem>.md with BE-<MODULE>-<NNN> cases and the seven required h3 sections; keep machine IDs/literals exact and do not execute pytest or modify production code/config or the README.",
+                retryPolicy: BACKEND_TEST_MARKDOWN_BINDING_RETRY_POLICY,
+                outputContract: "Write exactly the frozen `{{item.markdownPath}}` Chinese module Markdown case-card file with BE-<MODULE>-<NNN> cases and the seven required h3 sections; keep machine IDs/literals exact and do not execute pytest or modify production code/config or the README.",
                 subtaskPromptTemplate: [
-                    "This is a required file-generation node for exactly one Markdown module. Read the upstream run-owned Markdown plan artifact at `{{item.planReadPath}}` (Coverage Scope + Coverage Matrix + Module Index) and the bounded references, then immediately use write tools to create the single file testcase/md/{{item.stem}}.md. Do not read or recreate testcase/md/README.md. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists. Do not modify any other module file.",
+                    "This is a required file-generation node for exactly one Markdown module. Read the upstream run-owned Markdown plan artifact at `{{item.planReadPath}}` (Coverage Scope + Coverage Matrix + Module Index) and the bounded references, then immediately use write tools to create the single frozen file `{{item.markdownPath}}`. Do not read or recreate testcase/md/README.md. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists. Do not modify any other module file.",
                     "Output budget protocol (hard, max output <=16K per turn): Never paste full Matrix, other modules' case bodies, or source text into assistant chat. Each write/edit tool call touches at most one file (this module). Compact tables/lists are required; omitting required sections or in-scope variants is forbidden. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.",
                     "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed after the module file has been written, or IMPLEMENTATION_OUTCOME: blocked when precise missing evidence prevents safe generation. already-satisfied is not valid for this node.",
                     "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
                     'Write the module {{item.stem}} as readable case cards covering every in-scope rule/Test Point the README Coverage Matrix assigns to this module. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`), a bare number, or an alphabetic suffix such as `011A`. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射` Do not group cases under "## 测试类 ..." (or any h2 grouping) headings that force Cases down to h3; each Case must be a direct h2 (`##`), and its seven sections must be h3 (`###`) children of that Case. If you need to convey a pytest class, state it inside the Case\'s `### 自动化映射` instead. Forbidden: `## 测试类 X` then `### BE-PD-001` and `### 覆盖规则` at the same h3 level. Required: `## BE-PD-001` then `### 覆盖规则`.; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. The `验收标准` section must list the exact applicable `AC-...` IDs, and every explicit task AC must appear in at least one Case. Every automatable case explicitly names its target pytest script and exactly one primary symbol so traceability scans only that script/symbol. Evidence-only meta cases that exist solely for non-executable assertion/cross-cutting process evidence may declare `脚本：无` and `primary symbol：无` with empty `变体测试点`, and must not invent a business pytest item.',
-                    "Name this module file with the stable lowercase business stem `{{item.stem}}` (filename `testcase/md/{{item.stem}}.md`). Priority-only stems `p0`, `p1` and `p2` are forbidden and must never produce `p0.md` or `test_p0.py`. Pure hexadecimal/hash-like opaque stems such as `a401606` and `deadbeef` are also forbidden. Do not use Case-ID-like module filenames. For every automatable case, `自动化映射` must name exactly `testcase/test_{{item.stem}}.py`, where the module stem is this Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `health` → `testcase/test_health.py`; `resource_notes` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
+                    "Name this module file with the exact frozen Module Index stem `{{item.stem}}` (filename `{{item.markdownPath}}`). Never reinterpret or rename an explicit-user-layout stem. Priority-only stems `p0`, `p1` and `p2` are forbidden and must never produce `p0.md` or `test_p0.py`. Pure hexadecimal/hash-like opaque stems such as `a401606` and `deadbeef` are also forbidden. Do not use Case-ID-like module filenames. For every automatable case, `自动化映射` must name exactly `{{item.pytestPath}}`, where the module stem is this Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `health` → `testcase/test_health.py`; `resource_notes` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
+                    "AUTOMATION_BINDING_FORMAT_V1 is a literal machine contract. Under every Case's `### 自动化映射`, write these independent lines exactly: `- 脚本：<path|无>`, `- primary symbol：<symbol|无>`, `- 变体测试点：<semicolon-separated TP IDs|无>`, `- 场景断言测试点：<semicolon-separated TP IDs|无>`, `- 横切证据测试点：<semicolon-separated TP IDs|无>`. TP IDs must be on the same line after the colon. Forbidden classification forms include `TP-X（变体测试点）`, `[变体测试点] TP-X`, `【变体测试点】：TP-X`, pipe-delimited annotations, tables, or nested TP lists. Before returning, verify that the Case `### 测试点` exact set equals the pairwise-disjoint union of the three canonical binding lines; do not add, remove, rename or duplicate a TP to make the format pass.",
                     "Scenario Partition slots: when README declares `## Scenario Partitions`, every slot of each declared partition MUST appear in this module's Cases as exactly one variant Test Point with the deterministic ID `TP-<Partition ID>-<VALUE-TOKEN>` (each-value), `TP-<Partition ID>-OMITTED` (optional axis only) and exactly one `TP-<Partition ID>-NOT-IN-SET` complement slot with `intent=enum-invalid`. Example: Partition ID `SP-GET-API-RESOURCE-NOTES-STATUS` → `TP-SP-GET-API-RESOURCE-NOTES-STATUS-ACTIVE`. Slot IDs copy the declared Partition ID exactly; never drop the HTTP method, invent, merge, renumber or split slot IDs. Before returning, derive the complete exact slot set from every applicable Scenario Partitions row and verify that the module Cases declare and bind every slot assigned by the Coverage Matrix; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Prefer ONE Case per partition with a parameter table over duplicated Cases per value. The not-in-set slot value must be a concrete literal absent from the Domain (e.g. `UNKNOWN_TYPE`) and its expected result must come from the bound source — when Expected by Slot is GAP, the Case states the expectation as GAP evidence, never a guessed 空列表/400. Never create cross-axis combination variants beyond the single documented nominal.",
                     "For every variant Test Point, write its machine-checkable `场景意图: <TP-ID>; operation=...; target=...; intent=...` line inside that same Case body/自动化映射. Never collect Scenario Intent lines in a file-level appendix, implementation-details block, or another Case; local TP ownership is mandatory.",
                     "Every Case must keep at least one numbered executable line under `### 操作步骤`; a compact variant/result table may follow but must not replace the numbered action anchor. Keep numbered/bulleted independently assertable results under `### 预期结果`. The exact `### 操作步骤` and `### 预期结果` headings must remain present for every Case, including compact/table-based Cases; never compress later Cases by dropping required headings. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.",
@@ -4781,7 +4848,7 @@ async function buildBackendTestHybridDag(sources) {
             "For every variant Test Point, ensure the Markdown scenario intent is machine-checkable and located inside that same Case body/自动化映射, never in a file-level appendix, implementation-details block, or another Case. Use an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target. For intent=missing/empty/default-omit, pytest may use `_OMIT` or delete the key; for intent=enum-invalid use a concrete invalid enum literal (for example `UNKNOWN_STATUS`), never `_OMIT`/missing-key; for trim/padded samples use `custom-literal:trim` or a real padded string, not a bare token like `filter-active` when the intent is `custom-literal:ACTIVE`.",
             "Treat the requirement document as the coverage baseline; scope is limited to operations/rules it (or its referenced API contract) describes, and API contract evidence supplements scenario dimensions. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT. Directly add in-scope omissions; reject scope expansion to operations absent from the requirement document; undefined impact remains GAP/CONFLICT rather than invented behavior.",
             "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in the immutable run-owned plan artifact, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, and missing or drifted script/function mapping where it can be derived.",
-            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, then perform an exact-set check: each Case's `### 测试点` set must equal (not merely contain) the union of those three binding lists; delete stale/legacy aliases and ensure every binding-list Test Point is present, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
+            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, preserve every frozen Module Index filename exactly (never rename an explicit-user-layout module; model-derived invalid stems must have been rejected before map expansion), normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, then perform an exact-set check: each Case's `### 测试点` set must equal (not merely contain) the union of those three binding lists; delete stale/legacy aliases and ensure every binding-list Test Point is present, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
             "This is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; every label must occupy its own machine-readable list line, and a Case must never concatenate target/setup operations or multiple `Payload Contract` tokens onto one line, and explanatory prose/details must not repeat any `Payload Contract:` token; never infer missing keys or enum values. A target GET/DELETE operation with no request body must remain `Payload Contract: none` even when its setup journey performs POST/PUT with a DTO; setup payloads never redefine the target Case payload contract. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.",
             "For affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints. Do not invent a concrete identifier type when the source only requires presence; for a missing-resource 404 path with unspecified identifier syntax/type, synchronize the Case to a create-delete-derived valid identifier journey rather than an arbitrary UUID/text placeholder.",
             "Scenario Partitions synchronization: when the run-owned plan declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Before returning, derive the complete exact slot set from every legal Scenario Partitions row and compare it with both the binding Coverage Matrix Rule's Required Test Points and the final Case `### 测试点`/`变体测试点` sets; directly add every missing exact slot to the already-assigned Case IDs; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Directly add missing slot rows/Cases. Record an illegal plan Partition row that has no source-backed finite domain as GAP/CONFLICT and remove only its derived `TP-SP-*` slots/Cases from target modules; never modify the immutable plan artifact. Never delete a legal source-backed partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.",
@@ -4834,10 +4901,10 @@ async function buildBackendTestHybridDag(sources) {
         writePolicy: "read-only",
         allowedPaths: ro,
         forbiddenPaths: forbidden,
-        outputContract: "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256} parsed from the run-owned Markdown plan artifact, so the pytest map shard set and every child planReadPath deterministically match the Markdown map manifest.",
-        subtask_prompt: "Parse only the run-owned generate-backend-md-plan-pi/plan.md artifact and emit exactly one trailing JSON line {modules:[{stem,planReadPath}],planReadPath,planSha256}. Reuse the same plan-derived Module Index contract as the Markdown manifest; do not search for or fall back to testcase/**/README.md. No file writes.",
+        outputContract: "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256,moduleLayout} parsed from the final strict-layout-validated run-owned Markdown plan artifact, matching the Markdown map manifest.",
+        subtask_prompt: "Parse only the final run-owned generate-backend-md-plan-pi/plan.md artifact with the same strict module-layout and output-budget contract; do not search for or fall back to testcase/**/README.md. No project file writes.",
         shell: {
-            commands: [buildBackendTestModuleManifestShellCommand(layout)],
+            commands: [buildBackendTestModuleManifestShellCommand(layout, taskConfig.backendTest?.moduleLayout)],
             cwd: ".",
             timeoutMs: 60000,
         },
@@ -4873,7 +4940,7 @@ async function buildBackendTestHybridDag(sources) {
                 toolProfile: "write",
                 complexity: "MED",
                 writePolicy: "exclusive",
-                allowedPaths: ["testcase/test_{{item.stem}}.py"],
+                allowedPaths: ["{{item.pytestPath}}"],
                 forbiddenPaths: Array.from(new Set([
                     ...forbidden,
                     "testcase/md/**",
@@ -4882,22 +4949,22 @@ async function buildBackendTestHybridDag(sources) {
                     "pyproject.toml",
                     "setup.cfg",
                 ])),
-                writeSet: ["testcase/test_{{item.stem}}.py"],
+                writeSet: ["{{item.pytestPath}}"],
                 writerOutcomePolicy: {
                     type: "implementation-outcome-v1",
                     requireChangedFiles: true,
                 },
                 retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
-                outputContract: "Write exactly one pytest module file testcase/test_<stem>.py whose actual test function region contains the exact Case ID, preferably in the function name or docstring. testcase/md/<module>.md (excluding README.md) maps one-to-one to testcase/test_<module>.py; never merge or split modules. No JSON and no pytest execution.",
+                outputContract: "Write exactly the frozen pytest module file `{{item.pytestPath}}` whose actual test function region contains the exact Case ID, preferably in the function name or docstring. the frozen `{{item.markdownPath}}` maps one-to-one to `{{item.pytestPath}}`; never merge or split modules. No JSON and no pytest execution.",
                 subtaskPromptTemplate: [
-                    "Convert the single Markdown module testcase/md/{{item.stem}}.md into one self-contained pytest module. Before writing, also read the run-owned Markdown plan artifact at `{{item.planReadPath}}` and use its explicit API target/environment table as the authoritative fallback base URL for every module. A task/Markdown `API_BASE_URL` target takes precedence over project README dev-server URLs; never infer a backend API fallback from a frontend/Vite port such as localhost:3000. After reading the module Markdown, the run-owned plan artifact, and the bounded pytest config/conftest, immediately use write tools to create the single file testcase/test_{{item.stem}}.py. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.",
-                    "Output budget protocol (hard, max output <=16K per turn): Write exactly one test_{{item.stem}}.py. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.",
+                    "Convert the single frozen Markdown module `{{item.markdownPath}}` into one self-contained pytest module. Before writing, also read the run-owned Markdown plan artifact at `{{item.planReadPath}}` and use its explicit API target/environment table as the authoritative fallback base URL for every module. A task/Markdown `API_BASE_URL` target takes precedence over project README dev-server URLs; never infer a backend API fallback from a frontend/Vite port such as localhost:3000. After reading the module Markdown, the run-owned plan artifact, and the bounded pytest config/conftest, immediately use write tools to create the single frozen file `{{item.pytestPath}}`. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.",
+                    "Output budget protocol (hard, max output <=16K per turn): Write exactly the frozen `{{item.pytestPath}}`. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.",
                     "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize. Hard contract: request payload dicts may only contain DTO field keys from Payload Allowed Paths; never put expect/expected/echo_* helper keys inside the JSON body dict. Path/query/header identifiers and scenario-control metadata (including `id`, expected codes, and selector labels) must stay in separate pytest parameters and helper arguments; never merge them into a DTO patch or JSON body unless that exact path is allowed by the Markdown payload contract. Normalize the configured API base URL with `rstrip(\"/\")` (or equivalently join exactly one slash) before appending endpoint paths; generated requests must never contain a `//api/...` path. When the bound source documents a concrete non-secret local API URL, generated clients must use it as the fallback in `os.environ.get(\"API_BASE_URL\", \"<documented-url>\")`; do not require an otherwise-uninjected environment variable or fail setup solely because it is absent. Missing-field helpers must remove keys idempotently with `payload.pop(field, None)`, never `del payload[field]`, because optional fields may already be absent.",
                     "For every response contract that requires an object or pagination envelope, first assert that each envelope/data value is a dict and that required keys exist, then index fields and assert values. Never let an incidental KeyError or list/string TypeError stand in for the explicit response-shape contract failure.",
                     'Ensure every automatable final Markdown Case ID in this module appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. Skip evidence-only meta Cases that declare `脚本/primary symbol=无` with empty variants; do not invent a business pytest symbol for them. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id="TP-...")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use a literal direct `pytest.param(..., id=...)` expression for every row; never hide or wrap it behind `_post_case`, `_put_case`, row-factory functions, comprehensions, generators, or dynamically returned parameter lists; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). Implement request dictionaries so their direct and nested key paths and enum literals exactly satisfy the Case `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; for `Payload Contract: none`, do not invent a JSON/body DTO. GET/DELETE setup journeys may create resources, but their setup DTO must not change the target operation\'s no-body payload contract. No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task\'s explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.',
-                    "Name the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly one `testcase/test_{{item.stem}}.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.",
+                    "Name the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly the frozen `{{item.pytestPath}}`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the frozen manifest pytest path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.",
                     "Scenario Partition slots: every `TP-<Partition ID>-...` variant Test Point declared by this module's Markdown MUST become exactly one literal direct `pytest.param(..., id=\"TP-<Partition ID>-...\")` row with the exact slot ID; the not-in-set slot passes a concrete literal absent from the documented Domain (e.g. `UNKNOWN_TYPE`) — never `_OMIT`, never a descriptive token. Never split one slot into multiple params or merge several slots under a family TP id. Slot filtering requests hit the documented list endpoint with the slot value as the query/path filter.",
-                    "Keep this module self-contained: define module-local fixtures and helpers directly in testcase/test_{{item.stem}}.py, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.",
+                    "Keep this module self-contained: define module-local fixtures and helpers directly in `{{item.pytestPath}}`, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.",
                     "Materialize every automatable Markdown Case exactly once as one canonical primary pytest symbol. Preserve every explicit variant Test Point as a stable pytest.param id and every assertion/cross-cutting binding as declared. Build request payloads from the effective Markdown test data literally: keep all declared DTO keys, nested shapes, enum values, missing/null/boundary variants and business-state preconditions; never substitute guessed convenience fields or rename contract fields. Never assert an identifier's concrete Python/JSON type unless the Markdown or bound contract explicitly declares that type; when only presence is required, accept any non-null scalar identifier and serialize it safely into the path. For a nonexistent-resource 404 Case whose identifier syntax/type is not declared, obtain a syntactically valid identifier from a live create response and delete it before the 404 request; never invent an arbitrary UUID/text identifier that may fail path conversion with 400. Respect every local helper's actual return signature: never tuple-unpack a scalar status/id/helper result, and never treat a tuple response as a scalar.",
                     "Do not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
                     ...(sharedSetupPytestPrompt ? [sharedSetupPytestPrompt] : []),

package/dist/workflows/dag/node-execution.js

@@ -305,6 +305,26 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
     }
     if (previousFailureCategory === "incomplete-write-set") {
         const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
+        const bindingOnly = task.id?.startsWith("generate-backend-md-case-") === true &&
+            (recoveryTargetPaths?.length ?? 0) === 1 &&
+            Object.values(recoveryDiagnostics ?? {}).flat().some((detail) => /(?:unclassified Test Points|duplicate Test Point bindings)/i.test(detail));
+        if (bindingOnly) {
+            const target = recoveryTargetPaths[0];
+            const diagnostics = (recoveryDiagnostics?.[target] ?? []).slice(0, 4);
+            return [
+                "<retry_instruction>",
+                "BACKEND_TEST_LIGHTWEIGHT_BINDING_REPAIR attempt=1/1",
+                `target_path=${target}`,
+                "Read and edit only that single Markdown file. Do not read the PRD, references, plan, other modules, pytest, source code, or reports.",
+                "Modify only the affected Case `### 自动化映射` binding lines. Preserve every Case ID, Rule, Test Point, scenario intent, payload contract, script path, primary symbol, step and expected result.",
+                "Materialize exactly these canonical lines in every affected Case: `- 变体测试点：...`, `- 场景断言测试点：...`, `- 横切证据测试点：...`; use `无` for an empty set.",
+                "Do not guess a classification from negation, alternatives or vague prose. If exact classification cannot be proven from the same Case, return IMPLEMENTATION_OUTCOME: blocked without changing the file.",
+                "Diagnostics:",
+                ...diagnostics.map((detail) => `- ${detail}`),
+                "After editing, verify the declared Test Point set exactly equals the disjoint union of the three binding lists. Return a short IMPLEMENTATION_OUTCOME only.",
+                "</retry_instruction>",
+            ].join("\n");
+        }
         // Embed concrete missing/broken paths from the run-owned progress facts
         // so the continuation attempt is fully self-contained and never reads
         // a forbidden `.harness/**` evidence file. When the loader finds no

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

@@ -209,6 +209,11 @@ export const BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY = {
         INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
     ],
 };
+/** Markdown shard writers use one full attempt plus at most one bounded binding repair. */
+export const BACKEND_TEST_MARKDOWN_BINDING_RETRY_POLICY = {
+    ...BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
+    maxAttempts: 2,
+};
 /**
  * Deterministic helper: is this raw failure category eligible for retry under
  * the given policy? Pure function; executor never decides retry eligibility.

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

@@ -148,7 +148,7 @@
 				"validate-backend-test-environment-shell"
 			],
 			"complexity": "MED",
-			"subtask_prompt": "This is a required plan-generation node. Read only the strict read set and return the complete Markdown plan in the assistant response. The runtime persists the response as a run-owned Harness artifact named generate-backend-md-plan-pi/plan.md. Do not write testcase/md/README.md or any project file; module case cards are written by downstream sharded nodes.\n\nOutput budget protocol (hard, max output <=16K per turn): Never paste full Matrix, case bodies, or source text into assistant chat. README holds only Scope+Matrix+module index; never inline full case bodies. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.\n\nReturn the complete plan as plain Markdown. Do not emit JSON or code fences. The plan must contain the exact ## Coverage Scope, ## Coverage Matrix and ## Module Index sections required by the downstream manifest.\n\nRead the upstream environment report only through the strict read set. Generate the Markdown-first backend test plan; it will be persisted under the current DAG run's Harness artifacts, not under testcase/md/.\n\nWrite human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.\n\nCreate the concise plan entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in the plan artifact.\n\nBefore the Coverage Matrix, write a mandatory machine-readable `## Coverage Scope` section in the plan artifact using exactly `| Field | Value |`, immediately followed by the separator row `|---|---|`, and these six unique rows: `Change Classification`, `Coverage Policy`, `Affected Operations`, `Affected Rule Keys`, `Regression Floor`, `Scope Evidence`. Always set `Change Classification` to `new-operation` and `Coverage Policy` to `full-contract`; do NOT reason about whether operations are new or existing. Cover all in-scope rules from the requirement document at full depth; treat the product requirement as the coverage baseline and use API contract evidence (fields/status/enum/boundary/format) to supplement scenario dimensions. Scope is limited to operations/rules the requirement document (or its referenced API contract) explicitly describes; do not expand to unrelated operations that the requirement does not mention. List affected operations exactly as `METHOD /path`, stable rule keys separated by semicolons, and precise source pointers as Scope Evidence.\n\nCoverage depth is full over the in-scope rules: fully cover every documented status, request/response field rule, requiredness, enum, boundary, format, auth and business state of each affected operation the requirement describes, but do not re-test unrelated operations the requirement does not mention. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT.\n\nBefore writing cases, build the mandatory machine-readable Coverage Matrix inside the plan artifact itself. Its section heading line must be exactly `## Coverage Matrix` with no numeric prefix/suffix; never place the canonical Matrix only in a module file. Use this exact header: `| Rule Key | Priority | Source | Endpoint/Field | Dimension | Rule | Required Test Points | Case IDs | Status |`. Every data row must contain exactly 9 pipe-delimited cells and must never omit `Dimension`; use concise dimensions such as requirement, operation, response-status, requiredness, enum, boundary, format, business-state or error. Use only P0/P1/P2 and COVERED/PARTIAL/GAP/CONFLICT. Use stable `TP-<UPPERCASE-HYPHENATED-ID>` test points separated by semicolons.\n\nEach Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.\n\nCoverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.\n\nFor uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.\n\nMandatory module index: include a `## Module Index` table in the plan artifact that lists every planned module as a canonical relative link of the exact form `[label](./<stem>.md)` plus a `testcase/md/<stem>.md` path cell, so a downstream deterministic manifest can parse the module list. Group by stable business resource/domain, not by CRUD operation: one resource's list/detail/create/update/delete cases belong in one module such as `resource_notes`; split only when a single module would exceed the per-child 16K output protocol, keep the total module count at the smallest safe value, and never exceed 8 modules. Name each module file with a stable lowercase business stem such as `health` or `resource_notes`. Pure hexadecimal/hash-like opaque stems such as `a401606` or `deadbeef` are forbidden. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix and never defines module files. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. The relative link target MUST equal the on-disk filename stem the sharded writer will create. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.\n\nScenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional. Before returning, expand every declared partition into its complete deterministic exact slot ID set: one `TP-<Partition ID>-<VALUE-TOKEN>` per Domain value, `TP-<Partition ID>-OMITTED` only for an optional axis, and exactly one `TP-<Partition ID>-NOT-IN-SET`. Every expanded slot ID must appear verbatim in the binding Rule's `Required Test Points` cell and be assigned to concrete Case IDs in that same Coverage Matrix row; ordinary alias/family Test Points do not replace this inventory. Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.\n\nBefore finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.\n\nRead only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
+			"subtask_prompt": "This is a required plan-generation node. Read only the strict read set and return the complete Markdown plan in the assistant response. The runtime persists the response as a run-owned Harness artifact named generate-backend-md-plan-pi/plan.md. Do not write testcase/md/README.md or any project file; module case cards are written by downstream sharded nodes.\n\nOutput budget protocol (hard, max output <=16K per turn): Never paste full Matrix, case bodies, or source text into assistant chat. README holds only Scope+Matrix+module index; never inline full case bodies. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.\n\nReturn the complete plan as plain Markdown. Do not emit JSON or code fences. The plan must contain the exact ## Coverage Scope, ## Coverage Matrix and ## Module Index sections required by the downstream manifest.\n\nRead the upstream environment report only through the strict read set. Generate the Markdown-first backend test plan; it will be persisted under the current DAG run's Harness artifacts, not under testcase/md/.\n\nWrite human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.\n\nCreate the concise plan entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in the plan artifact.\n\nBefore the Coverage Matrix, write a mandatory machine-readable `## Coverage Scope` section in the plan artifact using exactly `| Field | Value |`, immediately followed by the separator row `|---|---|`, and these six unique rows: `Change Classification`, `Coverage Policy`, `Affected Operations`, `Affected Rule Keys`, `Regression Floor`, `Scope Evidence`. Always set `Change Classification` to `new-operation` and `Coverage Policy` to `full-contract`; do NOT reason about whether operations are new or existing. Cover all in-scope rules from the requirement document at full depth; treat the product requirement as the coverage baseline and use API contract evidence (fields/status/enum/boundary/format) to supplement scenario dimensions. Scope is limited to operations/rules the requirement document (or its referenced API contract) explicitly describes; do not expand to unrelated operations that the requirement does not mention. List affected operations exactly as `METHOD /path`, stable rule keys separated by semicolons, and precise source pointers as Scope Evidence.\n\nCoverage depth is full over the in-scope rules: fully cover every documented status, request/response field rule, requiredness, enum, boundary, format, auth and business state of each affected operation the requirement describes, but do not re-test unrelated operations the requirement does not mention. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT.\n\nBefore writing cases, build the mandatory machine-readable Coverage Matrix inside the plan artifact itself. Its section heading line must be exactly `## Coverage Matrix` with no numeric prefix/suffix; never place the canonical Matrix only in a module file. Use this exact header: `| Rule Key | Priority | Source | Endpoint/Field | Dimension | Rule | Required Test Points | Case IDs | Status |`. Every data row must contain exactly 9 pipe-delimited cells and must never omit `Dimension`; use concise dimensions such as requirement, operation, response-status, requiredness, enum, boundary, format, business-state or error. Use only P0/P1/P2 and COVERED/PARTIAL/GAP/CONFLICT. Use stable `TP-<UPPERCASE-HYPHENATED-ID>` test points separated by semicolons.\n\nEach Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.\n\nCoverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.\n\nFor uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.\n\nMandatory module layout contract: first inspect the PRIMARY requirement for an explicit list of required Markdown/Python output path pairs. When explicit paths are present, they are authoritative `explicit-user-layout`: reproduce their exact filenames, count and one-to-one pairs in Module Index; do not rename, merge, split, omit or add a module from reference/example scripts. Only when the primary requirement has no explicit file layout may you derive the smallest `business-resource-layout`. Existing examples, historical regression functions and shared setup may add evidence/assertions to an existing required module, but never create an extra physical module by themselves. A reference-only `resp_regression`, positive/negative/boundary/error/response module is forbidden.\n\nInclude exactly one `## Module Index` table with this exact header: `| Module Stem | Business Resource | Owned Operations | Owned Rule Keys | Case IDs | Split Reason | Markdown Path | Pytest Path |`. Use canonical relative links `[label](./<stem>.md)` inside the Markdown Path cell followed by the resolved `${layout.markdownDir}/<stem>.md` path. Split Reason is exactly one of `explicit-user-layout`, `primary-business-resource`, `independent-business-resource`, or `output-budget`. Group by stable business resource/domain, not by CRUD operation, AC, parameter/field axis, scenario type or regression purpose: one resource's list/detail/create/update/delete and its filters/response assertions/regression floor belong in one module. Multiple modules owning the same exact `METHOD /path` are forbidden unless every such row is `explicit-user-layout` from primary-requirement path pairs or has a documented `output-budget` proof. Keep the total module count at the smallest safe value and never exceed 8 modules. Name model-derived modules with stable lowercase business stems such as `health` or `resource_notes`; explicit-user-layout preserves the primary requirement filename stem even when it is more specific. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix. Pure hexadecimal/hash-like opaque stems and test-purpose-only stems are forbidden. Do not use Case-ID-like module filenames. The relative link target, Markdown Path, Pytest Path and downstream automation mapping must be one-to-one and exact; for model-derived modules the default pair remains `testcase/md/<module>.md` and `testcase/test_<module>.py`, while explicit-user-layout preserves the primary requirement paths. Do not hand-write a conflicting module count in prose; the Module Index row count is the only count truth.\n\nScenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional. Before returning, expand every declared partition into its complete deterministic exact slot ID set: one `TP-<Partition ID>-<VALUE-TOKEN>` per Domain value, `TP-<Partition ID>-OMITTED` only for an optional axis, and exactly one `TP-<Partition ID>-NOT-IN-SET`. Every expanded slot ID must appear verbatim in the binding Rule's `Required Test Points` cell and be assigned to concrete Case IDs in that same Coverage Matrix row; ordinary alias/family Test Points do not replace this inventory. Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.\n\nBefore finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.\n\nRead only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
 			"executor": "pi",
 			"role": "planner",
 			"toolProfile": "read-only",
@@ -185,18 +185,18 @@
 				"generate-backend-md-plan-pi"
 			],
 			"complexity": "LOW",
-			"subtask_prompt": "Parse only $HARNESS_DAG_RUN_DIR/generate-backend-md-plan-pi/plan.md and emit exactly one trailing JSON line {modules:[{stem,planReadPath}],planReadPath,planSha256}. No file writes and no testcase/md/README.md fallback.",
+			"subtask_prompt": "Parse only $HARNESS_DAG_RUN_DIR/generate-backend-md-plan-pi/plan.md, validate the optional strict module layout and output-budget proof, apply at most one deterministic Plan-only Module Index repair without project writes, then emit one JSON line. No testcase/md/README.md fallback.",
 			"executor": "shell",
 			"role": "verifier",
 			"writePolicy": "read-only",
 			"shell": {
 				"commands": [
-					"node -e \"eval(Buffer.from('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','base64').toString('utf8'))\""
+					"node -e \"eval(require('zlib').inflateRawSync(Buffer.from('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','base64')).toString('utf8'))\""
 				],
 				"timeoutMs": 60000,
 				"cwd": "."
 			},
-			"outputContract": "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256} parsed from the run-owned generate-backend-md-plan-pi/plan.md artifact using the same module-stem extractor as the Completeness Gate.",
+			"outputContract": "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256,moduleLayout} parsed from the run-owned generate-backend-md-plan-pi/plan.md artifact after strict-layout validation and at most one deterministic Plan-only repair.",
 			"allowedPaths": [
 				"testcase/**",
 				"docs/test-reports/**"
@@ -243,12 +243,12 @@
 						"verification-before-completion"
 					],
 					"complexity": "MED",
-					"subtaskPromptTemplate": "This is a required file-generation node for exactly one Markdown module. Read the upstream run-owned Markdown plan artifact at `{{item.planReadPath}}` (Coverage Scope + Coverage Matrix + Module Index) and the bounded references, then immediately use write tools to create the single file testcase/md/{{item.stem}}.md. Do not read or recreate testcase/md/README.md. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists. Do not modify any other module file.\n\nOutput budget protocol (hard, max output <=16K per turn): Never paste full Matrix, other modules' case bodies, or source text into assistant chat. Each write/edit tool call touches at most one file (this module). Compact tables/lists are required; omitting required sections or in-scope variants is forbidden. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.\n\nThe first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed after the module file has been written, or IMPLEMENTATION_OUTCOME: blocked when precise missing evidence prevents safe generation. already-satisfied is not valid for this node.\n\nWrite human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.\n\nWrite the module {{item.stem}} as readable case cards covering every in-scope rule/Test Point the README Coverage Matrix assigns to this module. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`), a bare number, or an alphabetic suffix such as `011A`. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射` Do not group cases under \"## 测试类 ...\" (or any h2 grouping) headings that force Cases down to h3; each Case must be a direct h2 (`##`), and its seven sections must be h3 (`###`) children of that Case. If you need to convey a pytest class, state it inside the Case's `### 自动化映射` instead. Forbidden: `## 测试类 X` then `### BE-PD-001` and `### 覆盖规则` at the same h3 level. Required: `## BE-PD-001` then `### 覆盖规则`.; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. The `验收标准` section must list the exact applicable `AC-...` IDs, and every explicit task AC must appear in at least one Case. Every automatable case explicitly names its target pytest script and exactly one primary symbol so traceability scans only that script/symbol. Evidence-only meta cases that exist solely for non-executable assertion/cross-cutting process evidence may declare `脚本：无` and `primary symbol：无` with empty `变体测试点`, and must not invent a business pytest item.\n\nName this module file with the stable lowercase business stem `{{item.stem}}` (filename `testcase/md/{{item.stem}}.md`). Priority-only stems `p0`, `p1` and `p2` are forbidden and must never produce `p0.md` or `test_p0.py`. Pure hexadecimal/hash-like opaque stems such as `a401606` and `deadbeef` are also forbidden. Do not use Case-ID-like module filenames. For every automatable case, `自动化映射` must name exactly `testcase/test_{{item.stem}}.py`, where the module stem is this Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `health` → `testcase/test_health.py`; `resource_notes` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.\n\nScenario Partition slots: when README declares `## Scenario Partitions`, every slot of each declared partition MUST appear in this module's Cases as exactly one variant Test Point with the deterministic ID `TP-<Partition ID>-<VALUE-TOKEN>` (each-value), `TP-<Partition ID>-OMITTED` (optional axis only) and exactly one `TP-<Partition ID>-NOT-IN-SET` complement slot with `intent=enum-invalid`. Example: Partition ID `SP-GET-API-RESOURCE-NOTES-STATUS` → `TP-SP-GET-API-RESOURCE-NOTES-STATUS-ACTIVE`. Slot IDs copy the declared Partition ID exactly; never drop the HTTP method, invent, merge, renumber or split slot IDs. Before returning, derive the complete exact slot set from every applicable Scenario Partitions row and verify that the module Cases declare and bind every slot assigned by the Coverage Matrix; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Prefer ONE Case per partition with a parameter table over duplicated Cases per value. The not-in-set slot value must be a concrete literal absent from the Domain (e.g. `UNKNOWN_TYPE`) and its expected result must come from the bound source — when Expected by Slot is GAP, the Case states the expectation as GAP evidence, never a guessed 空列表/400. Never create cross-axis combination variants beyond the single documented nominal.\n\nFor every variant Test Point, write its machine-checkable `场景意图: <TP-ID>; operation=...; target=...; intent=...` line inside that same Case body/自动化映射. Never collect Scenario Intent lines in a file-level appendix, implementation-details block, or another Case; local TP ownership is mandatory.\n\nEvery Case must keep at least one numbered executable line under `### 操作步骤`; a compact variant/result table may follow but must not replace the numbered action anchor. Keep numbered/bulleted independently assertable results under `### 预期结果`. The exact `### 操作步骤` and `### 预期结果` headings must remain present for every Case, including compact/table-based Cases; never compress later Cases by dropping required headings. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.\n\nIn every `自动化映射`, use exactly these machine-readable list labels: `脚本`, `primary symbol`, `变体测试点`, `场景断言测试点`, `横切证据测试点`, plus a deterministic payload contract. For operations without a request body write `Payload Contract: none`. Otherwise write `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum` (write `none` when there is no enum); nested fields use dot paths such as `approver.name`. Each Case describes exactly one target request payload contract: put every payload label on its own list line, never concatenate multiple operations or setup POST/PUT contracts into one label line, and never repeat a `Payload Contract:` token inside explanatory prose/details after the machine-readable line. Values must come only from bound API/DTO evidence, never guesses. Each Test Point from `### 测试点` must appear in exactly one binding list, and every Test Point named in any binding list must also be declared in that Case's `### 测试点`; write `无` for an empty list. A variant Test Point is atomic: one exact endpoint/input/precondition/outcome row equals one exact pytest item and one exact TP ID. If a parameter table has five rows, declare five distinct variant TP IDs in Markdown; never declare one family TP and append row suffixes only in pytest. Classify as `variant` only when endpoint, request input, precondition business state, or expected outcome genuinely changes and therefore needs an independent pytest parameter item. Classify CRUD checkpoints, status/body/header/schema assertions and multiple checks over the same response/journey as `assertion`; classify shared HTTP logging/redaction/truncation evidence as `cross-cutting`. Never create a Test Point merely to parameterize a checkpoint. Every non-cross-cutting TP ID is owned by exactly one Case; when the same response/schema/error assertion is needed in different Cases, use distinct Case-specific TP IDs instead of reusing one assertion TP across Cases. Keep the script path identical to the module one-to-one path and declare exactly one primary symbol named with the canonical Case prefix, for example `BE-RN-003` → `test_BE_RN_003_<description>`; non-Case-prefixed primary symbols are forbidden because parameterized item association must remain deterministic. For evidence-only meta Cases with no executable business journey, write `脚本：无` and `primary symbol：无`, keep `变体测试点：无`, and place process evidence only in assertion/cross-cutting lists. If the bound contract only says an identifier is returned/present, do not declare a concrete identifier type. If a 404 Case needs a nonexistent path identifier but its syntax/type is unspecified, define a create-delete-derived valid identifier journey instead of an arbitrary UUID/text placeholder. For redaction scenarios, list sensitive header/field key names only. Never write any header-name-and-value pair, credential placeholder, fake token, anti-example, or other secret-shaped literal in Markdown; state only that a test-only value is supplied at runtime and omitted. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.\n\nRead only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
-					"outputContract": "Write exactly one Chinese module Markdown case-card file testcase/md/<stem>.md with BE-<MODULE>-<NNN> cases and the seven required h3 sections; keep machine IDs/literals exact and do not execute pytest or modify production code/config or the README.",
+					"subtaskPromptTemplate": "This is a required file-generation node for exactly one Markdown module. Read the upstream run-owned Markdown plan artifact at `{{item.planReadPath}}` (Coverage Scope + Coverage Matrix + Module Index) and the bounded references, then immediately use write tools to create the single frozen file `{{item.markdownPath}}`. Do not read or recreate testcase/md/README.md. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists. Do not modify any other module file.\n\nOutput budget protocol (hard, max output <=16K per turn): Never paste full Matrix, other modules' case bodies, or source text into assistant chat. Each write/edit tool call touches at most one file (this module). Compact tables/lists are required; omitting required sections or in-scope variants is forbidden. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.\n\nThe first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed after the module file has been written, or IMPLEMENTATION_OUTCOME: blocked when precise missing evidence prevents safe generation. already-satisfied is not valid for this node.\n\nWrite human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.\n\nWrite the module {{item.stem}} as readable case cards covering every in-scope rule/Test Point the README Coverage Matrix assigns to this module. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`), a bare number, or an alphabetic suffix such as `011A`. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射` Do not group cases under \"## 测试类 ...\" (or any h2 grouping) headings that force Cases down to h3; each Case must be a direct h2 (`##`), and its seven sections must be h3 (`###`) children of that Case. If you need to convey a pytest class, state it inside the Case's `### 自动化映射` instead. Forbidden: `## 测试类 X` then `### BE-PD-001` and `### 覆盖规则` at the same h3 level. Required: `## BE-PD-001` then `### 覆盖规则`.; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. The `验收标准` section must list the exact applicable `AC-...` IDs, and every explicit task AC must appear in at least one Case. Every automatable case explicitly names its target pytest script and exactly one primary symbol so traceability scans only that script/symbol. Evidence-only meta cases that exist solely for non-executable assertion/cross-cutting process evidence may declare `脚本：无` and `primary symbol：无` with empty `变体测试点`, and must not invent a business pytest item.\n\nName this module file with the exact frozen Module Index stem `{{item.stem}}` (filename `{{item.markdownPath}}`). Never reinterpret or rename an explicit-user-layout stem. Priority-only stems `p0`, `p1` and `p2` are forbidden and must never produce `p0.md` or `test_p0.py`. Pure hexadecimal/hash-like opaque stems such as `a401606` and `deadbeef` are also forbidden. Do not use Case-ID-like module filenames. For every automatable case, `自动化映射` must name exactly `{{item.pytestPath}}`, where the module stem is this Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `health` → `testcase/test_health.py`; `resource_notes` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.\n\nAUTOMATION_BINDING_FORMAT_V1 is a literal machine contract. Under every Case's `### 自动化映射`, write these independent lines exactly: `- 脚本：<path|无>`, `- primary symbol：<symbol|无>`, `- 变体测试点：<semicolon-separated TP IDs|无>`, `- 场景断言测试点：<semicolon-separated TP IDs|无>`, `- 横切证据测试点：<semicolon-separated TP IDs|无>`. TP IDs must be on the same line after the colon. Forbidden classification forms include `TP-X（变体测试点）`, `[变体测试点] TP-X`, `【变体测试点】：TP-X`, pipe-delimited annotations, tables, or nested TP lists. Before returning, verify that the Case `### 测试点` exact set equals the pairwise-disjoint union of the three canonical binding lines; do not add, remove, rename or duplicate a TP to make the format pass.\n\nScenario Partition slots: when README declares `## Scenario Partitions`, every slot of each declared partition MUST appear in this module's Cases as exactly one variant Test Point with the deterministic ID `TP-<Partition ID>-<VALUE-TOKEN>` (each-value), `TP-<Partition ID>-OMITTED` (optional axis only) and exactly one `TP-<Partition ID>-NOT-IN-SET` complement slot with `intent=enum-invalid`. Example: Partition ID `SP-GET-API-RESOURCE-NOTES-STATUS` → `TP-SP-GET-API-RESOURCE-NOTES-STATUS-ACTIVE`. Slot IDs copy the declared Partition ID exactly; never drop the HTTP method, invent, merge, renumber or split slot IDs. Before returning, derive the complete exact slot set from every applicable Scenario Partitions row and verify that the module Cases declare and bind every slot assigned by the Coverage Matrix; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Prefer ONE Case per partition with a parameter table over duplicated Cases per value. The not-in-set slot value must be a concrete literal absent from the Domain (e.g. `UNKNOWN_TYPE`) and its expected result must come from the bound source — when Expected by Slot is GAP, the Case states the expectation as GAP evidence, never a guessed 空列表/400. Never create cross-axis combination variants beyond the single documented nominal.\n\nFor every variant Test Point, write its machine-checkable `场景意图: <TP-ID>; operation=...; target=...; intent=...` line inside that same Case body/自动化映射. Never collect Scenario Intent lines in a file-level appendix, implementation-details block, or another Case; local TP ownership is mandatory.\n\nEvery Case must keep at least one numbered executable line under `### 操作步骤`; a compact variant/result table may follow but must not replace the numbered action anchor. Keep numbered/bulleted independently assertable results under `### 预期结果`. The exact `### 操作步骤` and `### 预期结果` headings must remain present for every Case, including compact/table-based Cases; never compress later Cases by dropping required headings. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.\n\nIn every `自动化映射`, use exactly these machine-readable list labels: `脚本`, `primary symbol`, `变体测试点`, `场景断言测试点`, `横切证据测试点`, plus a deterministic payload contract. For operations without a request body write `Payload Contract: none`. Otherwise write `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum` (write `none` when there is no enum); nested fields use dot paths such as `approver.name`. Each Case describes exactly one target request payload contract: put every payload label on its own list line, never concatenate multiple operations or setup POST/PUT contracts into one label line, and never repeat a `Payload Contract:` token inside explanatory prose/details after the machine-readable line. Values must come only from bound API/DTO evidence, never guesses. Each Test Point from `### 测试点` must appear in exactly one binding list, and every Test Point named in any binding list must also be declared in that Case's `### 测试点`; write `无` for an empty list. A variant Test Point is atomic: one exact endpoint/input/precondition/outcome row equals one exact pytest item and one exact TP ID. If a parameter table has five rows, declare five distinct variant TP IDs in Markdown; never declare one family TP and append row suffixes only in pytest. Classify as `variant` only when endpoint, request input, precondition business state, or expected outcome genuinely changes and therefore needs an independent pytest parameter item. Classify CRUD checkpoints, status/body/header/schema assertions and multiple checks over the same response/journey as `assertion`; classify shared HTTP logging/redaction/truncation evidence as `cross-cutting`. Never create a Test Point merely to parameterize a checkpoint. Every non-cross-cutting TP ID is owned by exactly one Case; when the same response/schema/error assertion is needed in different Cases, use distinct Case-specific TP IDs instead of reusing one assertion TP across Cases. Keep the script path identical to the module one-to-one path and declare exactly one primary symbol named with the canonical Case prefix, for example `BE-RN-003` → `test_BE_RN_003_<description>`; non-Case-prefixed primary symbols are forbidden because parameterized item association must remain deterministic. For evidence-only meta Cases with no executable business journey, write `脚本：无` and `primary symbol：无`, keep `变体测试点：无`, and place process evidence only in assertion/cross-cutting lists. If the bound contract only says an identifier is returned/present, do not declare a concrete identifier type. If a 404 Case needs a nonexistent path identifier but its syntax/type is unspecified, define a create-delete-derived valid identifier journey instead of an arbitrary UUID/text placeholder. For redaction scenarios, list sensitive header/field key names only. Never write any header-name-and-value pair, credential placeholder, fake token, anti-example, or other secret-shaped literal in Markdown; state only that a test-only value is supplied at runtime and omitted. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.\n\nRead only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
+					"outputContract": "Write exactly the frozen `{{item.markdownPath}}` Chinese module Markdown case-card file with BE-<MODULE>-<NNN> cases and the seven required h3 sections; keep machine IDs/literals exact and do not execute pytest or modify production code/config or the README.",
 					"toolProfile": "write",
 					"writePolicy": "exclusive",
 					"allowedPaths": [
-						"testcase/md/{{item.stem}}.md"
+						"{{item.markdownPath}}"
 					],
 					"forbiddenPaths": [
 						".harness/**",
@@ -256,19 +256,19 @@
 						"artifacts/**"
 					],
 					"writeSet": [
-						"testcase/md/{{item.stem}}.md"
+						"{{item.markdownPath}}"
 					],
 					"readSet": [
 						"{{item.planReadPath}}",
 						"source/需求.md",
-						"testcase/md/{{item.stem}}.md"
+						"{{item.markdownPath}}"
 					],
 					"writerOutcomePolicy": {
 						"type": "implementation-outcome-v1",
 						"requireChangedFiles": true
 					},
 					"retryPolicy": {
-						"maxAttempts": 3,
+						"maxAttempts": 2,
 						"backoff": "exponential",
 						"initialDelayMs": 2000,
 						"maxDelayMs": 30000,
@@ -291,7 +291,7 @@
 				"materialize-backend-md-module-manifest-shell"
 			],
 			"complexity": "MED",
-			"subtask_prompt": "Perform one gap-targeted synchronization, not a full-suite rewrite or stylistic review. Read the immutable run-owned Markdown plan from the direct upstream manifest's planReadPath. Start from explicit bound source IDs/error codes/DTO fields/normative quoted rules and the plan Coverage Matrix; open and edit only modules that own a missing or conflicting rule. Never create or edit testcase/md/README.md and never modify the run-owned plan artifact. Preserve unrelated valid modules byte-for-byte and avoid optional wording cleanup.\n\nOutput budget protocol: never dump full Matrix/case bodies into assistant chat. Inspect the immutable run-owned plan first, build a concise target list from its Matrix and Module Index, then read/write only target modules one file per tool call. Do not traverse every module when the Matrix and source token inventory show no gap; return `already-satisfied`. When adding omitted in-scope cases, keep every required section. Do not bulk-delete in-scope cases to save tokens.\n\nFor every variant Test Point, ensure the Markdown scenario intent is machine-checkable and located inside that same Case body/自动化映射, never in a file-level appendix, implementation-details block, or another Case. Use an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target. For intent=missing/empty/default-omit, pytest may use `_OMIT` or delete the key; for intent=enum-invalid use a concrete invalid enum literal (for example `UNKNOWN_STATUS`), never `_OMIT`/missing-key; for trim/padded samples use `custom-literal:trim` or a real padded string, not a bare token like `filter-active` when the intent is `custom-literal:ACTIVE`.\n\nTreat the requirement document as the coverage baseline; scope is limited to operations/rules it (or its referenced API contract) describes, and API contract evidence supplements scenario dimensions. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT. Directly add in-scope omissions; reject scope expansion to operations absent from the requirement document; undefined impact remains GAP/CONFLICT rather than invented behavior.\n\nCheck AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in the immutable run-owned plan artifact, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, and missing or drifted script/function mapping where it can be derived.\n\nCorrect testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, then perform an exact-set check: each Case's `### 测试点` set must equal (not merely contain) the union of those three binding lists; delete stale/legacy aliases and ensure every binding-list Test Point is present, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.\n\nThis is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; every label must occupy its own machine-readable list line, and a Case must never concatenate target/setup operations or multiple `Payload Contract` tokens onto one line, and explanatory prose/details must not repeat any `Payload Contract:` token; never infer missing keys or enum values. A target GET/DELETE operation with no request body must remain `Payload Contract: none` even when its setup journey performs POST/PUT with a DTO; setup payloads never redefine the target Case payload contract. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.\n\nFor affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints. Do not invent a concrete identifier type when the source only requires presence; for a missing-resource 404 path with unspecified identifier syntax/type, synchronize the Case to a create-delete-derived valid identifier journey rather than an arbitrary UUID/text placeholder.\n\nScenario Partitions synchronization: when the run-owned plan declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Before returning, derive the complete exact slot set from every legal Scenario Partitions row and compare it with both the binding Coverage Matrix Rule's Required Test Points and the final Case `### 测试点`/`变体测试点` sets; directly add every missing exact slot to the already-assigned Case IDs; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Directly add missing slot rows/Cases. Record an illegal plan Partition row that has no source-backed finite domain as GAP/CONFLICT and remove only its derived `TP-SP-*` slots/Cases from target modules; never modify the immutable plan artifact. Never delete a legal source-backed partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.\n\nBefore returning, verify that every explicit source AC/REQ/BR, error code and strong DTO field token appears in the run-owned plan or an applicable module Case. If a fact cannot be safely automated, retain it as GAP/CONFLICT with its exact source pointer instead of dropping it. Return already-satisfied only when no target file needs an incremental edit.\n\nRead only indexed source paths. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
+			"subtask_prompt": "Perform one gap-targeted synchronization, not a full-suite rewrite or stylistic review. Read the immutable run-owned Markdown plan from the direct upstream manifest's planReadPath. Start from explicit bound source IDs/error codes/DTO fields/normative quoted rules and the plan Coverage Matrix; open and edit only modules that own a missing or conflicting rule. Never create or edit testcase/md/README.md and never modify the run-owned plan artifact. Preserve unrelated valid modules byte-for-byte and avoid optional wording cleanup.\n\nOutput budget protocol: never dump full Matrix/case bodies into assistant chat. Inspect the immutable run-owned plan first, build a concise target list from its Matrix and Module Index, then read/write only target modules one file per tool call. Do not traverse every module when the Matrix and source token inventory show no gap; return `already-satisfied`. When adding omitted in-scope cases, keep every required section. Do not bulk-delete in-scope cases to save tokens.\n\nFor every variant Test Point, ensure the Markdown scenario intent is machine-checkable and located inside that same Case body/自动化映射, never in a file-level appendix, implementation-details block, or another Case. Use an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target. For intent=missing/empty/default-omit, pytest may use `_OMIT` or delete the key; for intent=enum-invalid use a concrete invalid enum literal (for example `UNKNOWN_STATUS`), never `_OMIT`/missing-key; for trim/padded samples use `custom-literal:trim` or a real padded string, not a bare token like `filter-active` when the intent is `custom-literal:ACTIVE`.\n\nTreat the requirement document as the coverage baseline; scope is limited to operations/rules it (or its referenced API contract) describes, and API contract evidence supplements scenario dimensions. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT. Directly add in-scope omissions; reject scope expansion to operations absent from the requirement document; undefined impact remains GAP/CONFLICT rather than invented behavior.\n\nCheck AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in the immutable run-owned plan artifact, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, and missing or drifted script/function mapping where it can be derived.\n\nCorrect testcase/md/** directly: add documented omissions, remove unsupported cases, preserve every frozen Module Index filename exactly (never rename an explicit-user-layout module; model-derived invalid stems must have been rejected before map expansion), normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, then perform an exact-set check: each Case's `### 测试点` set must equal (not merely contain) the union of those three binding lists; delete stale/legacy aliases and ensure every binding-list Test Point is present, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.\n\nThis is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; every label must occupy its own machine-readable list line, and a Case must never concatenate target/setup operations or multiple `Payload Contract` tokens onto one line, and explanatory prose/details must not repeat any `Payload Contract:` token; never infer missing keys or enum values. A target GET/DELETE operation with no request body must remain `Payload Contract: none` even when its setup journey performs POST/PUT with a DTO; setup payloads never redefine the target Case payload contract. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.\n\nFor affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints. Do not invent a concrete identifier type when the source only requires presence; for a missing-resource 404 path with unspecified identifier syntax/type, synchronize the Case to a create-delete-derived valid identifier journey rather than an arbitrary UUID/text placeholder.\n\nScenario Partitions synchronization: when the run-owned plan declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Before returning, derive the complete exact slot set from every legal Scenario Partitions row and compare it with both the binding Coverage Matrix Rule's Required Test Points and the final Case `### 测试点`/`变体测试点` sets; directly add every missing exact slot to the already-assigned Case IDs; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Directly add missing slot rows/Cases. Record an illegal plan Partition row that has no source-backed finite domain as GAP/CONFLICT and remove only its derived `TP-SP-*` slots/Cases from target modules; never modify the immutable plan artifact. Never delete a legal source-backed partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.\n\nBefore returning, verify that every explicit source AC/REQ/BR, error code and strong DTO field token appears in the run-owned plan or an applicable module Case. If a fact cannot be safely automated, retain it as GAP/CONFLICT with its exact source pointer instead of dropping it. Return already-satisfied only when no target file needs an incremental edit.\n\nRead only indexed source paths. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
 			"executor": "pi",
 			"role": "implementer",
 			"toolProfile": "write",
@@ -383,18 +383,18 @@
 				"generate-backend-pytest-plan-pi"
 			],
 			"complexity": "LOW",
-			"subtask_prompt": "Parse only the run-owned generate-backend-md-plan-pi/plan.md artifact and emit exactly one trailing JSON line {modules:[{stem,planReadPath}],planReadPath,planSha256}. Reuse the same plan-derived Module Index contract as the Markdown manifest; do not search for or fall back to testcase/**/README.md. No file writes.",
+			"subtask_prompt": "Parse only the final run-owned generate-backend-md-plan-pi/plan.md artifact with the same strict module-layout and output-budget contract; do not search for or fall back to testcase/**/README.md. No project file writes.",
 			"executor": "shell",
 			"role": "verifier",
 			"writePolicy": "read-only",
 			"shell": {
 				"commands": [
-					"node -e \"eval(Buffer.from('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','base64').toString('utf8'))\""
+					"node -e \"eval(require('zlib').inflateRawSync(Buffer.from('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','base64')).toString('utf8'))\""
 				],
 				"timeoutMs": 60000,
 				"cwd": "."
 			},
-			"outputContract": "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256} parsed from the run-owned Markdown plan artifact, so the pytest map shard set and every child planReadPath deterministically match the Markdown map manifest.",
+			"outputContract": "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256,moduleLayout} parsed from the final strict-layout-validated run-owned Markdown plan artifact, matching the Markdown map manifest.",
 			"allowedPaths": [
 				"testcase/**",
 				"docs/test-reports/**"
@@ -441,12 +441,12 @@
 						"verification-before-completion"
 					],
 					"complexity": "MED",
-					"subtaskPromptTemplate": "Convert the single Markdown module testcase/md/{{item.stem}}.md into one self-contained pytest module. Before writing, also read the run-owned Markdown plan artifact at `{{item.planReadPath}}` and use its explicit API target/environment table as the authoritative fallback base URL for every module. A task/Markdown `API_BASE_URL` target takes precedence over project README dev-server URLs; never infer a backend API fallback from a frontend/Vite port such as localhost:3000. After reading the module Markdown, the run-owned plan artifact, and the bounded pytest config/conftest, immediately use write tools to create the single file testcase/test_{{item.stem}}.py. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.\n\nOutput budget protocol (hard, max output <=16K per turn): Write exactly one test_{{item.stem}}.py. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.\n\nAlign every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize. Hard contract: request payload dicts may only contain DTO field keys from Payload Allowed Paths; never put expect/expected/echo_* helper keys inside the JSON body dict. Path/query/header identifiers and scenario-control metadata (including `id`, expected codes, and selector labels) must stay in separate pytest parameters and helper arguments; never merge them into a DTO patch or JSON body unless that exact path is allowed by the Markdown payload contract. Normalize the configured API base URL with `rstrip(\"/\")` (or equivalently join exactly one slash) before appending endpoint paths; generated requests must never contain a `//api/...` path. When the bound source documents a concrete non-secret local API URL, generated clients must use it as the fallback in `os.environ.get(\"API_BASE_URL\", \"<documented-url>\")`; do not require an otherwise-uninjected environment variable or fail setup solely because it is absent. Missing-field helpers must remove keys idempotently with `payload.pop(field, None)`, never `del payload[field]`, because optional fields may already be absent.\n\nFor every response contract that requires an object or pagination envelope, first assert that each envelope/data value is a dict and that required keys exist, then index fields and assert values. Never let an incidental KeyError or list/string TypeError stand in for the explicit response-shape contract failure.\n\nEnsure every automatable final Markdown Case ID in this module appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. Skip evidence-only meta Cases that declare `脚本/primary symbol=无` with empty variants; do not invent a business pytest symbol for them. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id=\"TP-...\")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use a literal direct `pytest.param(..., id=...)` expression for every row; never hide or wrap it behind `_post_case`, `_put_case`, row-factory functions, comprehensions, generators, or dynamically returned parameter lists; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). Implement request dictionaries so their direct and nested key paths and enum literals exactly satisfy the Case `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; for `Payload Contract: none`, do not invent a JSON/body DTO. GET/DELETE setup journeys may create resources, but their setup DTO must not change the target operation's no-body payload contract. No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task's explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.\n\nName the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly one `testcase/test_{{item.stem}}.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.\n\nScenario Partition slots: every `TP-<Partition ID>-...` variant Test Point declared by this module's Markdown MUST become exactly one literal direct `pytest.param(..., id=\"TP-<Partition ID>-...\")` row with the exact slot ID; the not-in-set slot passes a concrete literal absent from the documented Domain (e.g. `UNKNOWN_TYPE`) — never `_OMIT`, never a descriptive token. Never split one slot into multiple params or merge several slots under a family TP id. Slot filtering requests hit the documented list endpoint with the slot value as the query/path filter.\n\nKeep this module self-contained: define module-local fixtures and helpers directly in testcase/test_{{item.stem}}.py, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.\n\nMaterialize every automatable Markdown Case exactly once as one canonical primary pytest symbol. Preserve every explicit variant Test Point as a stable pytest.param id and every assertion/cross-cutting binding as declared. Build request payloads from the effective Markdown test data literally: keep all declared DTO keys, nested shapes, enum values, missing/null/boundary variants and business-state preconditions; never substitute guessed convenience fields or rename contract fields. Never assert an identifier's concrete Python/JSON type unless the Markdown or bound contract explicitly declares that type; when only presence is required, accept any non-null scalar identifier and serialize it safely into the path. For a nonexistent-resource 404 Case whose identifier syntax/type is not declared, obtain a syntactically valid identifier from a live create response and delete it before the 404 request; never invent an arbitrary UUID/text identifier that may fail path conversion with 400. Respect every local helper's actual return signature: never tuple-unpack a scalar status/id/helper result, and never treat a tuple response as a scalar.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
-					"outputContract": "Write exactly one pytest module file testcase/test_<stem>.py whose actual test function region contains the exact Case ID, preferably in the function name or docstring. testcase/md/<module>.md (excluding README.md) maps one-to-one to testcase/test_<module>.py; never merge or split modules. No JSON and no pytest execution.",
+					"subtaskPromptTemplate": "Convert the single frozen Markdown module `{{item.markdownPath}}` into one self-contained pytest module. Before writing, also read the run-owned Markdown plan artifact at `{{item.planReadPath}}` and use its explicit API target/environment table as the authoritative fallback base URL for every module. A task/Markdown `API_BASE_URL` target takes precedence over project README dev-server URLs; never infer a backend API fallback from a frontend/Vite port such as localhost:3000. After reading the module Markdown, the run-owned plan artifact, and the bounded pytest config/conftest, immediately use write tools to create the single frozen file `{{item.pytestPath}}`. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.\n\nOutput budget protocol (hard, max output <=16K per turn): Write exactly the frozen `{{item.pytestPath}}`. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.\n\nAlign every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize. Hard contract: request payload dicts may only contain DTO field keys from Payload Allowed Paths; never put expect/expected/echo_* helper keys inside the JSON body dict. Path/query/header identifiers and scenario-control metadata (including `id`, expected codes, and selector labels) must stay in separate pytest parameters and helper arguments; never merge them into a DTO patch or JSON body unless that exact path is allowed by the Markdown payload contract. Normalize the configured API base URL with `rstrip(\"/\")` (or equivalently join exactly one slash) before appending endpoint paths; generated requests must never contain a `//api/...` path. When the bound source documents a concrete non-secret local API URL, generated clients must use it as the fallback in `os.environ.get(\"API_BASE_URL\", \"<documented-url>\")`; do not require an otherwise-uninjected environment variable or fail setup solely because it is absent. Missing-field helpers must remove keys idempotently with `payload.pop(field, None)`, never `del payload[field]`, because optional fields may already be absent.\n\nFor every response contract that requires an object or pagination envelope, first assert that each envelope/data value is a dict and that required keys exist, then index fields and assert values. Never let an incidental KeyError or list/string TypeError stand in for the explicit response-shape contract failure.\n\nEnsure every automatable final Markdown Case ID in this module appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. Skip evidence-only meta Cases that declare `脚本/primary symbol=无` with empty variants; do not invent a business pytest symbol for them. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id=\"TP-...\")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use a literal direct `pytest.param(..., id=...)` expression for every row; never hide or wrap it behind `_post_case`, `_put_case`, row-factory functions, comprehensions, generators, or dynamically returned parameter lists; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). Implement request dictionaries so their direct and nested key paths and enum literals exactly satisfy the Case `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; for `Payload Contract: none`, do not invent a JSON/body DTO. GET/DELETE setup journeys may create resources, but their setup DTO must not change the target operation's no-body payload contract. No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task's explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.\n\nName the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly the frozen `{{item.pytestPath}}`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the frozen manifest pytest path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.\n\nScenario Partition slots: every `TP-<Partition ID>-...` variant Test Point declared by this module's Markdown MUST become exactly one literal direct `pytest.param(..., id=\"TP-<Partition ID>-...\")` row with the exact slot ID; the not-in-set slot passes a concrete literal absent from the documented Domain (e.g. `UNKNOWN_TYPE`) — never `_OMIT`, never a descriptive token. Never split one slot into multiple params or merge several slots under a family TP id. Slot filtering requests hit the documented list endpoint with the slot value as the query/path filter.\n\nKeep this module self-contained: define module-local fixtures and helpers directly in `{{item.pytestPath}}`, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.\n\nMaterialize every automatable Markdown Case exactly once as one canonical primary pytest symbol. Preserve every explicit variant Test Point as a stable pytest.param id and every assertion/cross-cutting binding as declared. Build request payloads from the effective Markdown test data literally: keep all declared DTO keys, nested shapes, enum values, missing/null/boundary variants and business-state preconditions; never substitute guessed convenience fields or rename contract fields. Never assert an identifier's concrete Python/JSON type unless the Markdown or bound contract explicitly declares that type; when only presence is required, accept any non-null scalar identifier and serialize it safely into the path. For a nonexistent-resource 404 Case whose identifier syntax/type is not declared, obtain a syntactically valid identifier from a live create response and delete it before the 404 request; never invent an arbitrary UUID/text identifier that may fail path conversion with 400. Respect every local helper's actual return signature: never tuple-unpack a scalar status/id/helper result, and never treat a tuple response as a scalar.\n\nDo not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
+					"outputContract": "Write exactly the frozen pytest module file `{{item.pytestPath}}` whose actual test function region contains the exact Case ID, preferably in the function name or docstring. the frozen `{{item.markdownPath}}` maps one-to-one to `{{item.pytestPath}}`; never merge or split modules. No JSON and no pytest execution.",
 					"toolProfile": "write",
 					"writePolicy": "exclusive",
 					"allowedPaths": [
-						"testcase/test_{{item.stem}}.py"
+						"{{item.pytestPath}}"
 					],
 					"forbiddenPaths": [
 						".harness/**",
@@ -459,7 +459,7 @@
 						"setup.cfg"
 					],
 					"writeSet": [
-						"testcase/test_{{item.stem}}.py"
+						"{{item.pytestPath}}"
 					],
 					"writerOutcomePolicy": {
 						"type": "implementation-outcome-v1",

package/package.json

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