@tea-agent/loop-agent 0.39.0-next.9 → 0.39.1

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

@@ -6,6 +6,7 @@ import { createWriteStream } from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
 import { isPriorityOnlyBackendTestModuleStem } from "./backend-test-module-stem.js";
+import { resolveBackendTestLayout, } from "./backend-test-layout.js";
 import { parseJacocoXml, } from "./backend-test-coverage-contract.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
 const execFileAsync = promisify(execFile);
@@ -14,10 +15,22 @@ const execFileAsync = promisify(execFile);
 // heading width cannot collapse the whole manifest/report to zero cases.
 const CASE_ID = /\bBE-[A-Z0-9_-]+-\d{2,3}\b/g;
 const CANONICAL_CASE_ID = /\bBE-[A-Z0-9]+(?:-[A-Z0-9]+)*-\d{3}\b/;
+const SHARED_SETUP_REF_LINE = /^\s*引用前置\s*:\s*(\S+)\s*#\s*([A-Za-z0-9_.\-\u4e00-\u9fa5]+)\s*$/;
+const sharedSetupAnchorRe = /^SS-[A-Z0-9][A-Z0-9._-]*$/i;
+export function extractBackendSharedSetupRefs(markdown) {
+    const refs = [];
+    for (const line of markdown.split("\n")) {
+        const match = SHARED_SETUP_REF_LINE.exec(line);
+        if (match) {
+            refs.push({ raw: match[0].trim(), path: match[1], anchor: match[2] });
+        }
+    }
+    return refs;
+}
 const AC_ID = /\bAC-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
 const SECRET = /(?:password|passwd|secret|token|api[_-]?key|private[_-]?key|authorization)\s*[:=]\s*\S+/i;
 const SECRET_ASSIGNMENT = /\b(password|passwd|secret|token|api[_-]?key|private[_-]?key|authorization|cookie|set-cookie|credential)\b\s*[:=]\s*([^\r\n,;]+)/gi;
-const SECRET_VALUE = /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:ghp|github_pat|xox[baprs]|AKIA|sk)[-_A-Za-z0-9]{12,}\b/i;
+const SECRET_VALUE = /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:ghp|github_pat|xox[baprs]|AKIA)[-_A-Za-z0-9]{12,}\b|\bsk[-_][-_A-Za-z0-9]{10,}\b/i;
 const PLACEHOLDER_SECRET_VALUE = /^(?:<[^>]+>|\$\{[^}]+\}|\*+|x+|redacted|masked|example(?:[-_].*)?|sample(?:[-_].*)?|dummy(?:[-_].*)?|test(?:[-_].*)?|your[-_].*)$/i;
 const PLACEHOLDER = /\b(?:TODO|TBD|FIXME)\b|后续补充|暂不实现|接口正常|结果正确|按实际情况处理/i;
 const CASE_SECTION_ALIASES = {
@@ -187,13 +200,170 @@ export async function inspectBackendTestEnvironment(input) {
         serverEntries,
     };
 }
-async function markdownFiles(root) {
-    const directory = path.join(root, "testcase", "md");
+/**
+ * Filenames declared by the canonical `## Module Index` section of the backend
+ * README. Only a unique exact `## Module Index` heading is authoritative; a
+ * missing/duplicate section yields an empty declaration set (callers then fall
+ * back to the whole directory so legacy workspaces without a manifest keep
+ * their prior behaviour). Reads `[x](./x.md)`, `` `testcase/md/<x>.md` `` and
+ * inline `x.md` tokens inside the section; README.md itself is never a module.
+ */
+export function extractDeclaredModuleIndexFilenames(readme) {
+    const lines = readme
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n");
+    const headings = lines.flatMap((line, index) => line.trim() === "## Module Index" ? [index] : []);
+    if (headings.length !== 1)
+        return [];
+    const start = headings[0] + 1;
+    const relativeEnd = lines
+        .slice(start)
+        .findIndex((line) => /^##\s+\S/.test(line.trim()));
+    const end = relativeEnd < 0 ? lines.length : start + relativeEnd;
+    const section = lines.slice(start, end).join("\n");
+    return unique([...section.matchAll(/`?[A-Za-z0-9_.-]+\.md`?/g)]
+        .map((match) => match[0].replaceAll("`", ""))
+        .filter((name) => name.toLowerCase() !== "readme.md"));
+}
+/**
+ * Count exact `## Module Index` headings in the backend README.
+ */
+function moduleIndexHeadingCountIn(readme) {
+    return readme
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n")
+        .filter((line) => line.trim() === "## Module Index").length;
+}
+/**
+ * Machine-readable fail-closed finding for an invalid backend-test Module Index.
+ * These are distinct states (missing/unreadable/duplicate/empty-unparsable) so a
+ * stripped Module Index can never silently fall back to a whole-directory scan.
+ */
+export function backendManifestStatusFinding(manifestStatus, moduleIndexHeadingCount = 0) {
+    switch (manifestStatus) {
+        case "missing":
+            return "README is missing; backend-test current round fails closed without a declarative Module Index";
+        case "unreadable":
+            return "README is unreadable; backend-test current round fails closed without a usable Module Index";
+        case "duplicate":
+            return moduleIndexHeadingCount === 0
+                ? "README Module Index heading is missing; backend-test current round fails closed without a declarative Module Index"
+                : `duplicate ## Module Index heading (${moduleIndexHeadingCount} occurrences); backend-test current round fails closed without a unique Module Index`;
+        case "empty-unparsable":
+            return "README Module Index is empty/unparsable; backend-test current round fails closed with no declared module";
+        case "valid":
+            return "";
+    }
+}
+/**
+ * Resolve the current-round Markdown module manifest. The README `## Module
+ * Index` is the authoritative source for which module files belong to this
+ * round. Fail closed on every non-`valid` state (missing/unreadable/duplicate/
+ * empty-unparsable): the backend-test current round must NEVER re-scan the whole
+ * directory, or historical `.md` files could leak back into Case/coverage/
+ * partition facts.
+ *
+ * - `manifestStatus==="valid"`   — unique heading with >= 1 declared `.md` file.
+ * - `missing`                     — README file does not exist.
+ * - `unreadable`                  — README exists but could not be read.
+ * - `duplicate`                   — README has 0 or duplicate `## Module Index`.
+ * - `empty-unparsable`            — unique heading but no `.md` filename parsed.
+ * - `declaredMdFiles`  — declared filenames that exist on disk (relative paths).
+ * - `declaredMissing`  — declared filenames with no file on disk (fail-closed
+ *   evidence, never silently dropped).
+ * - `unmanifested`     — existing `.md` files that the Module Index does not
+ *   declare (non-silent advisory; they must not enter Case/coverage/partition).
+ */
+export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const readmePath = path.join(workspaceRoot, ...resolved.readmePath.split("/"));
+    const invalid = (manifestStatus, moduleIndexHeadingCount) => ({
+        hasManifest: false,
+        manifestStatus,
+        moduleIndexHeadingCount,
+        declaredStems: [],
+        declaredMdFiles: [],
+        declaredMissing: [],
+        unmanifested: [],
+    });
+    let readme = "";
+    if (await exists(readmePath)) {
+        try {
+            readme = await readFile(readmePath, "utf8");
+        }
+        catch {
+            // Unreadable README is fail-closed (not silently treated as no manifest).
+            return invalid("unreadable", 0);
+        }
+    }
+    else {
+        return invalid("missing", 0);
+    }
+    const moduleIndexHeadingCount = moduleIndexHeadingCountIn(readme);
+    if (moduleIndexHeadingCount !== 1) {
+        return invalid("duplicate", moduleIndexHeadingCount);
+    }
+    const declaredStems = extractDeclaredModuleIndexFilenames(readme);
+    if (declaredStems.length === 0) {
+        return invalid("empty-unparsable", moduleIndexHeadingCount);
+    }
+    const hasManifest = true;
+    const directory = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
+    let existingNames = [];
+    try {
+        existingNames = (await readdir(directory, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() &&
+            entry.name.toLowerCase().endsWith(".md") &&
+            entry.name.toLowerCase() !== "readme.md")
+            .map((entry) => entry.name);
+    }
+    catch {
+        // missing markdown directory -> no existing modules
+    }
+    const declaredByLower = new Map();
+    for (const name of declaredStems) {
+        const base = path.posix.basename(name);
+        declaredByLower.set(base.toLowerCase(), base);
+    }
+    const declaredMdFiles = [];
+    const declaredMissing = [];
+    for (const base of declaredByLower.values()) {
+        const disk = existingNames.find((name) => name.toLowerCase() === base.toLowerCase());
+        if (disk)
+            declaredMdFiles.push(`${resolved.markdownDir}/${disk}`);
+        else
+            declaredMissing.push(`${resolved.markdownDir}/${base}`);
+    }
+    const unmanifested = existingNames
+        .filter((name) => !declaredByLower.has(name.toLowerCase()))
+        .map((name) => `${resolved.markdownDir}/${name}`);
+    return {
+        hasManifest,
+        manifestStatus: "valid",
+        moduleIndexHeadingCount,
+        declaredStems,
+        declaredMdFiles: declaredMdFiles.sort(),
+        declaredMissing: declaredMissing.sort(),
+        unmanifested: unmanifested.sort(),
+    };
+}
+export async function markdownFiles(root, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const directory = path.join(root, ...resolved.markdownDir.split("/"));
     const entries = await readdir(directory, { withFileTypes: true });
-    return entries
+    const all = entries
         .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
         .map((entry) => path.join(directory, entry.name))
         .sort();
+    const manifest = await resolveBackendTestManifestModules(root, resolved);
+    if (manifest.manifestStatus !== "valid")
+        return [];
+    const declaredAbs = new Set(manifest.declaredMdFiles.map((rel) => path.join(root, ...rel.split("/")).toLowerCase()));
+    return all
+        .filter((file) => declaredAbs.has(file.toLowerCase()))
+        .sort();
 }
 function canonicalBackendCaseId(value) {
     const upper = value.toUpperCase();
@@ -303,6 +473,8 @@ function isCleanupStatement(value) {
         return false;
     if (/\b(?:assert|pytest\.fail|raise)\b/.test(trimmed))
         return false;
+    if (/\b[A-Za-z_][A-Za-z0-9_.]*request\s*\(\s*["']DELETE["']/i.test(trimmed))
+        return true;
     return /(?:^|[._])(?:cleanup|clean_up|teardown|delete|remove|close|release|rollback|disconnect|dispose|unlink)(?:[_(.]|$)/i.test(trimmed);
 }
 function findUnsafeSwallowedException(source) {
@@ -326,7 +498,18 @@ function findUnsafeSwallowedException(source) {
             continue;
         }
         const exceptionType = exceptMatch[2]?.trim() || "bare except";
-        if (exceptionType !== "requests.RequestException") {
+        const narrowDecodeTypes = exceptionType
+            .replace(/[()]/g, "")
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+        const precedingDecodeRegion = lines.slice(Math.max(0, index - 8), index).join("\n");
+        if (narrowDecodeTypes.length > 0 &&
+            narrowDecodeTypes.every((value) => value === "UnicodeDecodeError" || value === "json.JSONDecodeError") &&
+            /\.json\s*\(\s*\)/.test(precedingDecodeRegion)) {
+            continue;
+        }
+        if (!new Set(["requests.RequestException", "urllib.error.URLError", "httpx.RequestError"]).has(exceptionType)) {
             return exceptionType;
         }
         let tryIndex = index - 1;
@@ -366,9 +549,18 @@ function httpLoggingFindings(relativeScript, source) {
     if (!hasHttpRequest)
         return [];
     const findings = [];
-    const hasRequestLog = /(?:print|log(?:ger)?\.(?:debug|info|warning|error))\s*\([^\n]*(?:request|请求)[^\n]*(?:method|url|path|params|query|json|body|payload|参数)/i.test(source);
-    const hasResponseLog = /(?:print|log(?:ger)?\.(?:debug|info|warning|error))\s*\([^\n]*(?:response|响应)[^\n]*(?:status|status_code|body|json|text|result|结果)/i.test(source);
-    const hasSanitizer = /\b(?:sanitize|sanitise|redact|mask)[A-Za-z0-9_]*\s*\(|\b[A-Za-z0-9_]*(?:sanitize|sanitise|redact|mask)[A-Za-z0-9_]*\s*\(/i.test(source);
+    const hasRequestLog = /(?:print|log(?:ger)?\.(?:debug|info|warning|error))\s*\([^\n]*(?:request|请求)[^\n]*(?:method|url|path|params|query|json|body|payload|参数)/i.test(source)
+        || /["']record["']\s*:\s*["']request["'][\s\S]{0,600}["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log[A-Za-z0-9_]*\s*\(\s*["'](?:HTTP|API)_REQUEST["'][\s\S]{0,600}["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source)
+        || /print\s*\(\s*f?["'](?:HTTP|API)(?:_|\s+)REQUEST\b/i.test(source) && /["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log\s*\(\s*["']REQUEST["'][\s\S]{0,600}["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source);
+    const hasResponseLog = /(?:print|log(?:ger)?\.(?:debug|info|warning|error))\s*\([^\n]*(?:response|响应)[^\n]*(?:status|status_code|body|json|text|result|结果)/i.test(source)
+        || /["']record["']\s*:\s*["']response["'][\s\S]{0,600}["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log[A-Za-z0-9_]*\s*\(\s*["'](?:HTTP|API)_RESPONSE["'][\s\S]{0,600}["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source)
+        || /print\s*\(\s*f?["'](?:HTTP|API)(?:_|\s+)RESPONSE\b/i.test(source) && /["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log\s*\(\s*["']RESPONSE["'][\s\S]{0,600}["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source);
+    const hasSanitizer = /\b(?:sanitize|sanitise|redact|mask)[A-Za-z0-9_]*\s*\(|\b[A-Za-z0-9_]*(?:sanitize|sanitise|redact|mask)[A-Za-z0-9_]*\s*\(/i.test(source)
+        || /(?:SENSITIVE_KEYS|sensitive_keys)[\s\S]{0,1600}["']<redacted>["']/i.test(source);
     const hasBoundedOutput = /(?:MAX_[A-Z_]*(?:LOG|BODY|RESPONSE)|max_(?:log|body|response)|truncate|truncat|\[:\s*\d{3,}\s*\])/i.test(source);
     if (!hasRequestLog)
         findings.push(`request logging evidence is missing in mapped backend pytest: ${relativeScript}`);
@@ -403,22 +595,34 @@ export function hasBlockingBackendMarkdownModuleStemFindings(report) {
     return /^## Module Stem Status\s*\r?\n\s*BLOCKED\s*$/m.test(report);
 }
 export async function validateBackendMarkdownCases(input) {
+    const layout = input.layout ?? resolveBackendTestLayout(undefined);
     const findings = [];
     const safetyFindings = [];
     const moduleStemFindings = [];
     let files = [];
     try {
-        files = await markdownFiles(input.workspaceRoot);
+        files = await markdownFiles(input.workspaceRoot, layout);
     }
     catch {
-        findings.push("missing testcase/md directory");
+        findings.push(`missing ${layout.markdownDir} directory`);
     }
-    const readme = path.join(input.workspaceRoot, "testcase", "md", "README.md");
+    const readme = path.join(input.workspaceRoot, ...layout.readmePath.split("/"));
     if (!(await exists(readme)))
-        findings.push("missing testcase/md/README.md");
+        findings.push(`missing ${layout.readmePath}`);
+    const manifest = await resolveBackendTestManifestModules(input.workspaceRoot, layout);
+    // Fail closed on README Module Index entries that were declared but never
+    // materialized — never let a declared module silently vanish from the round.
+    if (manifest.declaredMissing.length > 0) {
+        findings.push(`declared Markdown module is missing (Module Index): ${manifest.declaredMissing.join(", ")}`);
+    }
+    // Fail closed on every non-valid Module Index state: without a valid unique
+    // Module Index the current round must not re-scan historical `.md` files.
+    if (manifest.manifestStatus !== "valid") {
+        findings.push(backendManifestStatusFinding(manifest.manifestStatus, manifest.moduleIndexHeadingCount));
+    }
     const moduleFiles = files.filter((file) => path.basename(file).toLowerCase() !== "readme.md");
     if (moduleFiles.length === 0)
-        findings.push("no testcase/md module case file found");
+        findings.push(`no ${layout.markdownDir} module case file found`);
     const seen = new Map();
     const coveredAc = new Set();
     let caseCount = 0;
@@ -436,6 +640,18 @@ export async function validateBackendMarkdownCases(input) {
         if (PLACEHOLDER.test(markdown)) {
             findings.push(`placeholder or non-assertable wording in ${relativeFile}`);
         }
+        const sharedSetupRefs = extractBackendSharedSetupRefs(markdown);
+        for (const ref of sharedSetupRefs) {
+            if (!input.sharedSetup) {
+                findings.push(`shared setup reference without a bound document: ${ref.raw} in ${relativeFile}`);
+            }
+            else if (ref.path !== input.sharedSetup.path) {
+                findings.push(`shared setup reference cites unbound path ${ref.path} (bound: ${input.sharedSetup.path}) in ${relativeFile}`);
+            }
+            else if (ref.anchor !== "SS-DEFAULT" && !sharedSetupAnchorRe.test(ref.anchor)) {
+                findings.push(`shared setup reference anchor is not a stable SS ID and not SS-DEFAULT: ${ref.raw} in ${relativeFile}`);
+            }
+        }
         const cases = splitCases(markdown);
         if (cases.length === 0) {
             findings.push(`no BE-<MODULE>-<NNN> case heading in ${relativeFile}`);
@@ -459,6 +675,15 @@ export async function validateBackendMarkdownCases(input) {
                     findings.push(`${testCase.id} missing section: ${sectionAliases.join(" or ")}`);
                 }
             }
+            const bindingFinding = markdownTestPointBindingFinding(testCase.id, testCase.body);
+            if (bindingFinding)
+                findings.push(bindingFinding);
+            const payloadLabelFinding = markdownPayloadLabelFinding(testCase.id, testCase.body);
+            if (payloadLabelFinding)
+                findings.push(payloadLabelFinding);
+            const scenarioIntentFinding = markdownScenarioIntentFinding(testCase.id, testCase.body);
+            if (scenarioIntentFinding)
+                findings.push(scenarioIntentFinding);
             const acIds = unique(testCase.body.match(AC_ID) ?? []);
             acIds.forEach((id) => coveredAc.add(id));
             const steps = sectionBody(testCase.body, CASE_SECTION_ALIASES.steps);
@@ -469,9 +694,12 @@ export async function validateBackendMarkdownCases(input) {
             if (!hasAssertableExpectedResult(expected)) {
                 findings.push(`${testCase.id} has no structured expected result`);
             }
-            const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile);
+            const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
             const mappedScripts = extractMappedPytestScripts(testCase.body);
-            if (mappedScripts.length === 0) {
+            if (isEvidenceOnlyMarkdownCaseBody(testCase.body)) {
+                // Evidence-only meta cases intentionally declare 脚本/primary symbol as 无 and keep only assertion/cross-cutting TPs.
+            }
+            else if (mappedScripts.length === 0) {
                 findings.push(`${testCase.id} has no mapped pytest script in Automation Notes/自动化映射 (expected ${expectedScript} from module ${path.basename(relativeFile)})`);
             }
             else {
@@ -501,6 +729,7 @@ export async function validateBackendMarkdownCases(input) {
         `- Cases: ${caseCount}`,
         `- Covered AC IDs: ${[...coveredAc].sort().join(", ") || "none"}`,
         `- Environment evidence present: ${input.environmentMarkdown.trim() ? "yes" : "no"}`,
+        `- Manifest scope: ${manifest.manifestStatus === "valid" ? "declared-modules" : `fails-closed:${manifest.manifestStatus}`} (declared-missing=${manifest.declaredMissing.length}, unmanifested-advisory=${manifest.unmanifested.length}, module-index-heading-count=${manifest.moduleIndexHeadingCount})`,
         `- Findings: ${findings.length}`,
         "- Required sections: Preconditions/前置条件, Steps/操作步骤, Expected Results/预期结果",
         "- Source-reference validity check: not applied",
@@ -522,6 +751,13 @@ export async function validateBackendMarkdownCases(input) {
             ? safetyFindings.map((finding) => `- ${finding}`)
             : ["- No secret-shaped values detected."]),
         "",
+        "## Unmanifested Markdown Modules",
+        "",
+        "- Advisory: existing .md files not declared by the README Module Index are excluded from this round's Case/coverage/partition scope.",
+        ...(manifest.unmanifested.length > 0
+            ? manifest.unmanifested.map((item) => `- ${item}`)
+            : ["- None"]),
+        "",
         "## Findings",
         "",
         ...(findings.length > 0 ? findings.map((finding) => `- ${finding}`) : ["- None"]),
@@ -549,8 +785,9 @@ export function normalizeBackendTestModuleStem(moduleFileName) {
     return stem;
 }
 /** Expected pytest script path for a Markdown module file (basename or relative path). */
-export function expectedBackendTestPytestScriptForMarkdownModule(moduleFileName) {
-    return `testcase/test_${normalizeBackendTestModuleStem(moduleFileName)}.py`;
+export function expectedBackendTestPytestScriptForMarkdownModule(moduleFileName, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    return `${resolved.scriptDir}/test_${normalizeBackendTestModuleStem(moduleFileName)}.py`;
 }
 function extractMappedPytestScripts(testCaseBody) {
     const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
@@ -560,12 +797,79 @@ function extractMappedPytestScripts(testCaseBody) {
         .map((match) => match[1].replaceAll("\\", "/"))
         .filter((value) => !value.includes("..")));
 }
-function isSafeBackendPytestScript(script, workspaceRoot) {
+function markdownScenarioIntentFinding(testCaseId, testCaseBody) {
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!automation.trim())
+        return null;
+    const variantLine = /^(?:\s*[-*+]\s*)?(?:变体测试点|Variant Test Points)\s*[：:]\s*(.*)$/im.exec(automation)?.[1] ?? "";
+    const variants = unique(variantLine.match(/\bTP-[A-Z0-9-]+\b/g) ?? []);
+    if (variants.length === 0)
+        return null;
+    const localIntentIds = unique([...testCaseBody.matchAll(/(?:场景意图|Scenario Intent)\s*[：:]\s*(TP-[A-Z0-9-]+)/gi)].map((match) => match[1].toUpperCase()));
+    const missing = variants.filter((id) => !localIntentIds.includes(id.toUpperCase()));
+    return missing.length > 0
+        ? `${testCaseId} variant Test Points require a local Scenario Intent line inside the same Case: missing=${missing.join(", ")}`
+        : null;
+}
+function markdownPayloadLabelFinding(testCaseId, testCaseBody) {
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!automation.trim())
+        return null;
+    const payloadLabel = /Payload (?:Contract|Required Paths|Allowed Paths|Enum)\s*[:：]/gi;
+    for (const line of automation.split(/\r?\n/)) {
+        const matches = line.match(payloadLabel) ?? [];
+        if (matches.length === 0)
+            continue;
+        if (matches.length !== 1 || !/^\s*[-*+]\s*Payload (?:Contract|Required Paths|Allowed Paths|Enum)\s*[:：]/i.test(line)) {
+            return `${testCaseId} payload contract labels must each occupy one independent machine-readable list line`;
+        }
+    }
+    return null;
+}
+function markdownTestPointBindingFinding(testCaseId, testCaseBody) {
+    const declaredSection = sectionBody(testCaseBody, ["测试点", "Test Points"]);
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!declaredSection.trim() || !automation.trim())
+        return null;
+    const declared = unique(declaredSection.match(/\bTP-[A-Z0-9-]+\b/g) ?? []);
+    const bindingLines = [
+        /^(?:\s*[-*+]\s*)?(?:变体测试点|Variant Test Points)\s*[：:]\s*(.*)$/gim,
+        /^(?:\s*[-*+]\s*)?(?:场景断言测试点|Assertion Test Points)\s*[：:]\s*(.*)$/gim,
+        /^(?:\s*[-*+]\s*)?(?:横切证据测试点|Cross-Cutting Test Points)\s*[：:]\s*(.*)$/gim,
+    ];
+    const bound = unique(bindingLines.flatMap((pattern) => [...automation.matchAll(pattern)].flatMap((match) => match[1]?.match(/\bTP-[A-Z0-9-]+\b/g) ?? [])));
+    const missingBindings = declared.filter((id) => !bound.includes(id));
+    const undeclaredBindings = bound.filter((id) => !declared.includes(id));
+    if (missingBindings.length === 0 && undeclaredBindings.length === 0)
+        return null;
+    return `${testCaseId} Test Point set must exactly equal variant/assertion/cross-cutting binding union: unclassified=${missingBindings.join(", ") || "none"}; undeclared-bindings=${undeclaredBindings.join(", ") || "none"}`;
+}
+function isEvidenceOnlyMarkdownCaseBody(testCaseBody) {
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!automation.trim())
+        return false;
+    const scriptLine = /^\s*[-*+]\s*(?:脚本|script)\s*[：:]\s*(.*)$/im.exec(automation)?.[1]?.replaceAll("`", "").trim() ??
+        "";
+    const primaryLine = /^\s*[-*+]\s*(?:primary symbol|Primary Symbol|主测试符号)\s*[：:]\s*(.*)$/im.exec(automation)?.[1]
+        ?.replaceAll("`", "")
+        .trim() ?? "";
+    const noneLike = /^(?:none|无|n\/a|not-applicable)(?:\s*[（(].*[）)])?$/i;
+    const scriptIsNone = noneLike.test(scriptLine) || scriptLine.length === 0;
+    const primaryIsNone = noneLike.test(primaryLine) || primaryLine.length === 0;
+    const hasMappedScript = extractMappedPytestScripts(testCaseBody).length > 0;
+    const hasPrimary = /\btest_[A-Za-z0-9_]+\b/.test(primaryLine);
+    const hasVariant = /(?:变体测试点|Variant Test Points)\s*[：:]\s*(?!\s*(?:无|none)\b)[^\n]*\bTP-[A-Z0-9-]+/i.test(automation);
+    const hasAssertionOrCross = /(?:场景断言测试点|Assertion Test Points|横切证据测试点|Cross-Cutting Test Points)\s*[：:]\s*(?!\s*(?:无|none)\b)[^\n]*\bTP-[A-Z0-9-]+/i.test(automation);
+    return scriptIsNone && primaryIsNone && !hasMappedScript && !hasPrimary && !hasVariant && hasAssertionOrCross;
+}
+function isSafeBackendPytestScript(script, workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
     const absolute = path.resolve(workspaceRoot, script);
     const relative = path.relative(workspaceRoot, absolute).replaceAll(path.sep, "/");
+    const allowedRoots = [`${resolved.testRoot}/`];
     return (!relative.startsWith("..") &&
         !path.isAbsolute(relative) &&
-        script.startsWith("testcase/") &&
+        allowedRoots.some((prefix) => script.startsWith(prefix)) &&
         !script.includes("..") &&
         /^test_.*\.py$/i.test(path.basename(script)));
 }
@@ -609,8 +913,8 @@ function symbolCaseId(symbol) {
         ? canonicalBackendCaseId(match[1].replaceAll("_", "-"))
         : undefined;
 }
-export async function validateBackendMarkdownTraceability(workspaceRoot) {
-    const files = await markdownFiles(workspaceRoot);
+export async function validateBackendMarkdownTraceability(workspaceRoot, layout) {
+    const files = await markdownFiles(workspaceRoot, layout);
     const markdownIds = new Set();
     const expectedIdsByScript = new Map();
     const findings = [];
@@ -619,8 +923,11 @@ export async function validateBackendMarkdownTraceability(workspaceRoot) {
             continue;
         const content = await readFile(file, "utf8");
         for (const testCase of splitCases(content)) {
-            markdownIds.add(testCase.id);
             const scripts = extractMappedPytestScripts(testCase.body);
+            if (isEvidenceOnlyMarkdownCaseBody(testCase.body)) {
+                continue;
+            }
+            markdownIds.add(testCase.id);
             if (scripts.length === 0) {
                 findings.push(`${testCase.id} has no mapped pytest script in Automation Notes/自动化映射`);
                 continue;
@@ -632,6 +939,7 @@ export async function validateBackendMarkdownTraceability(workspaceRoot) {
             }
         }
     }
+    const resolvedLayout = layout ?? resolveBackendTestLayout(undefined);
     const mappings = new Map();
     const automationIds = new Set();
     let requestResponseLoggingFindingCount = 0;
@@ -640,7 +948,7 @@ export async function validateBackendMarkdownTraceability(workspaceRoot) {
         const relative = path.relative(workspaceRoot, absolute);
         if (relative.startsWith("..") ||
             path.isAbsolute(relative) ||
-            !relativeScript.startsWith("testcase/") ||
+            !relativeScript.startsWith(`${resolvedLayout.testRoot}/`) ||
             !/^test_.*\.py$/i.test(path.basename(relativeScript))) {
             findings.push(`unsafe mapped pytest script: ${relativeScript}`);
             continue;
@@ -713,8 +1021,9 @@ export async function validateBackendMarkdownTraceability(workspaceRoot) {
         ...(findings.length > 0 ? findings.map((finding) => `- ${finding}`) : ["- None"]),
     ].join("\n") + "\n");
 }
-export async function resolveBackendTestMappedPytestScripts(workspaceRoot) {
-    const files = await markdownFiles(workspaceRoot);
+export async function resolveBackendTestMappedPytestScripts(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const files = await markdownFiles(workspaceRoot, resolved);
     const expectedScripts = new Set();
     const existingScripts = new Set();
     const missingScripts = new Set();
@@ -735,7 +1044,7 @@ export async function resolveBackendTestMappedPytestScripts(workspaceRoot) {
         if (path.basename(file).toLowerCase() === "readme.md")
             continue;
         const relativeFile = path.relative(workspaceRoot, file).replaceAll(path.sep, "/");
-        const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile);
+        const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile, resolved);
         const markdown = await readFile(file, "utf8");
         const mappedFromModule = new Set();
         for (const testCase of splitCases(markdown)) {
@@ -755,14 +1064,14 @@ export async function resolveBackendTestMappedPytestScripts(workspaceRoot) {
             continue;
         }
         for (const script of mappedFromModule) {
-            if (!isSafeBackendPytestScript(script, workspaceRoot)) {
+            if (!isSafeBackendPytestScript(script, workspaceRoot, resolved)) {
                 throw new Error(`unsafe mapped pytest script: ${script}`);
             }
             if (await mappedScriptExists(path.resolve(workspaceRoot, script))) {
                 recordScript(script, relativeFile, true);
                 continue;
             }
-            if (!isSafeBackendPytestScript(expectedScript, workspaceRoot)) {
+            if (!isSafeBackendPytestScript(expectedScript, workspaceRoot, resolved)) {
                 throw new Error(`unsafe mapped pytest script: ${expectedScript}`);
             }
             recordScript(expectedScript, relativeFile, await mappedScriptExists(path.resolve(workspaceRoot, expectedScript)));
@@ -777,8 +1086,8 @@ export async function resolveBackendTestMappedPytestScripts(workspaceRoot) {
         missingScripts: unique(missingScripts),
     };
 }
-export async function collectBackendTestMappedPytestScripts(workspaceRoot) {
-    const resolution = await resolveBackendTestMappedPytestScripts(workspaceRoot);
+export async function collectBackendTestMappedPytestScripts(workspaceRoot, layout) {
+    const resolution = await resolveBackendTestMappedPytestScripts(workspaceRoot, layout);
     if (resolution.missingScripts.length > 0) {
         throw new Error(`mapped pytest script is missing: ${resolution.missingScripts[0]}`);
     }
@@ -791,8 +1100,8 @@ function cleanCaseTitle(rawHeading, id) {
         .replace(/^BE-[A-Z0-9_-]+-\d{2,3}\s*(?:[｜|—–-]\s*)?/i, "")
         .trim() || id;
 }
-export async function collectBackendTestHumanCaseCatalog(workspaceRoot) {
-    const files = await markdownFiles(workspaceRoot);
+export async function collectBackendTestHumanCaseCatalog(workspaceRoot, layout) {
+    const files = await markdownFiles(workspaceRoot, layout);
     const catalog = new Map();
     for (const file of files) {
         if (path.basename(file).toLowerCase() === "readme.md")
@@ -814,7 +1123,8 @@ export async function collectBackendTestHumanCaseCatalog(workspaceRoot) {
             });
         }
     }
-    const testcaseRoot = path.join(workspaceRoot, "testcase");
+    const resolvedLayout = layout ?? resolveBackendTestLayout(undefined);
+    const testcaseRoot = path.join(workspaceRoot, ...resolvedLayout.testRoot.split("/"));
     const pythonFiles = [];
     async function walk(directory) {
         for (const entry of await readdir(directory, { withFileTypes: true })) {

package/dist/workflows/dag/backend-test-module-stem.js

@@ -1,5 +1,7 @@
 import path from "node:path";
 const PRIORITY_ONLY_MODULE_STEMS = new Set(["p0", "p1", "p2"]);
+const OPAQUE_HASH_MODULE_STEM = /^[a-f][a-f0-9]{6,63}$/;
+export const BACKEND_TEST_MAX_MODULE_COUNT = 8;
 export function normalizeBackendTestModuleStemCandidate(raw) {
     return path.basename(raw)
         .replace(/\.(?:md|py)$/i, "")
@@ -11,6 +13,9 @@ export function normalizeBackendTestModuleStemCandidate(raw) {
 export function isPriorityOnlyBackendTestModuleStem(raw) {
     return PRIORITY_ONLY_MODULE_STEMS.has(normalizeBackendTestModuleStemCandidate(raw));
 }
+export function isOpaqueHashBackendTestModuleStem(raw) {
+    return OPAQUE_HASH_MODULE_STEM.test(normalizeBackendTestModuleStemCandidate(raw));
+}
 export function isPriorityOnlyBackendPytestScript(script) {
     const basename = path.posix.basename(script.replaceAll("\\", "/"));
     const match = /^test_(.+)\.py$/i.exec(basename);