@tea-agent/loop-agent 0.38.1 → 0.38.3

package/dist/workflows/dag/backend-test-scenario-partitions.js

@@ -0,0 +1,321 @@
+import { z } from "zod";
+/**
+ * Plan C: deterministic query/filter axis scenario partitions.
+ *
+ * A README `## Scenario Partitions` table declares one partition per
+ * filterable enum/classification axis on an affected list/query operation.
+ * The deterministic expander turns each declared partition into machine
+ * slots — the model never invents slot IDs:
+ *
+ *   each-value  one slot per legal domain value (intent=nominal-filter)
+ *   omitted     only when the contract marks the parameter optional
+ *   not-in-set  exactly one complement slot (intent=enum-invalid)
+ *
+ * `not-in-set` expected semantics must come from the bound source; when the
+ * source does not document the complement expectation, the partition row
+ * keeps the slot but the expected column stays GAP so N6 reports it instead
+ * of guessing "empty list" or "400".
+ */
+export const scenarioPartitionRowSchema = z.object({
+    partitionId: z.string().min(1),
+    operation: z.string().min(1),
+    axis: z.string().min(1),
+    /** Legal values copied verbatim from the bound OpenAPI enum / requirement sentence. */
+    domain: z.array(z.string().min(1)).min(1),
+    /** true when the parameter is optional and the omitted slot is required. */
+    optional: z.boolean(),
+    /**
+     * Complement expectation sourced from the contract. `unknown` keeps the
+     * not-in-set slot but marks expected as GAP (never guessed).
+     */
+    complementExpected: z.enum(["empty-result", "excluded-result", "unknown"]),
+    /** Which bind rule this partition enforces (advisory provenance). */
+    bindRule: z.string().min(1),
+}).strict();
+const PARTITION_HEADING = /^##\s+Scenario Partitions\s*$/;
+const PARTITION_TABLE_HEADER = /^\|\s*Partition ID\s*\|\s*Operation\s*\|\s*Axis\s*\|\s*Domain\s*\|\s*Required Slots\s*\|\s*Expected by Slot\s*\|\s*Bind Rule\s*\|\s*$/;
+const TABLE_ROW = /^\|(.+)\|$/;
+const FINITE_DOMAIN_MEMBER = /^[A-Za-z0-9]+(?:[._\- ][A-Za-z0-9]+)*$/;
+const RESERVED_SLOT_TOKENS = new Set(["OMITTED", "NOT-IN-SET"]);
+function splitCells(raw) {
+    return raw
+        .split("|")
+        .map((cell) => cell.trim())
+        .filter((cell, index, cells) => !(cell === "" && (index === 0 || index === cells.length - 1)));
+}
+/**
+ * Parse the `## Scenario Partitions` section of the README into declared
+ * partitions. Returns { partitions, issues }; issues are fail-closed parse
+ * problems (malformed table), while semantic gaps surface in expansion.
+ */
+export function parseScenarioPartitions(readmeMarkdown) {
+    const issues = [];
+    const partitions = [];
+    const lines = readmeMarkdown.split("\n");
+    const headingIndex = lines.findIndex((line) => PARTITION_HEADING.test(line));
+    if (headingIndex === -1)
+        return { partitions, issues };
+    // find table header within the section (before the next ## heading)
+    let headerIndex = -1;
+    for (let i = headingIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i]) && !PARTITION_HEADING.test(lines[i]))
+            break;
+        if (PARTITION_TABLE_HEADER.test(lines[i])) {
+            headerIndex = i;
+            break;
+        }
+    }
+    if (headerIndex === -1) {
+        issues.push("MISSING_PARTITION_TABLE: Scenario Partitions section has no canonical header row");
+        return { partitions, issues };
+    }
+    const seen = new Set();
+    for (let i = headerIndex + 2; i < lines.length; i++) {
+        const line = lines[i];
+        if (!TABLE_ROW.test(line)) {
+            if (/^##\s+/.test(line) || /^#\s+/.test(line))
+                break;
+            continue;
+        }
+        const cells = splitCells(line);
+        if (cells.length !== 7) {
+            issues.push(`MISSING_PARTITION: row has ${cells.length} cells, expected 7: ${line.trim()}`);
+            continue;
+        }
+        const [partitionId, operation, axis, domainRaw, requiredSlotsRaw, expectedBySlotRaw, bindRule,] = cells;
+        const domain = domainRaw
+            .split(/[;,，；]/)
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0);
+        if (domain.length === 0) {
+            issues.push(`MISSING_PARTITION: empty domain: ${partitionId}`);
+            continue;
+        }
+        const optional = /omit/i.test(requiredSlotsRaw);
+        const complementExpected = /empty[- ]?result/i.test(expectedBySlotRaw)
+            ? "empty-result"
+            : /excluded[- ]?result/i.test(expectedBySlotRaw)
+                ? "excluded-result"
+                : "unknown";
+        if (seen.has(partitionId)) {
+            issues.push(`MISSING_PARTITION: duplicate partition id ${partitionId}`);
+            continue;
+        }
+        seen.add(partitionId);
+        const domainIssue = describeInvalidPartitionDomain(domain);
+        if (domainIssue) {
+            issues.push(`INVALID_PARTITION_DOMAIN: partition ${partitionId} ${domainIssue}`);
+            continue;
+        }
+        partitions.push({
+            partitionId,
+            operation,
+            axis,
+            domain,
+            optional,
+            complementExpected,
+            bindRule,
+        });
+    }
+    return { partitions, issues };
+}
+function slotToken(value) {
+    return value
+        .trim()
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function describeInvalidPartitionDomain(domain) {
+    const tokens = [];
+    const seenTokens = new Set();
+    for (const value of domain) {
+        if (!FINITE_DOMAIN_MEMBER.test(value)) {
+            return `value is not a finite identifier member: ${value}`;
+        }
+        const token = slotToken(value);
+        if (!token) {
+            return `value cannot produce a stable non-empty slot token: ${value}`;
+        }
+        if (RESERVED_SLOT_TOKENS.has(token)) {
+            return `value maps to reserved slot token ${token}: ${value}`;
+        }
+        if (seenTokens.has(token)) {
+            return `values collapse to duplicate slot token ${token}`;
+        }
+        seenTokens.add(token);
+        tokens.push(token);
+    }
+    return tokens.length === 0 ? "domain produced no slot tokens" : undefined;
+}
+function normalizePartitionAxisName(value) {
+    return value.trim().replace(/^(?:query|path)\s*:\s*/i, "").toLowerCase();
+}
+function normalizePartitionOperation(value) {
+    return value.trim().replace(/\s+/g, " ").toUpperCase();
+}
+function sameFiniteSet(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const expected = new Set(left);
+    return right.every((value) => expected.has(value));
+}
+const STABLE_PARTITION_ID = /^SP-[A-Z0-9][A-Z0-9._-]*$/i;
+/**
+ * Slot IDs are `TP-<Partition ID>-<VALUE|OMITTED|NOT-IN-SET>`.
+ * The declared Partition ID is the single source of truth so model-written
+ * `TP-SP-GET-API-...` IDs match the expander (never drop the HTTP method).
+ */
+function partitionToken(row) {
+    const id = row.partitionId.trim();
+    if (STABLE_PARTITION_ID.test(id))
+        return `TP-${id.toUpperCase()}`;
+    return `TP-SP-${slotToken(row.operation)}-${slotToken(row.axis)}`;
+}
+/**
+ * Deterministically expand declared partitions into slots. Pure function:
+ * same input rows always produce the same slot IDs.
+ */
+export function expandScenarioPartitions(partitions) {
+    const slots = [];
+    for (const row of partitions) {
+        if (describeInvalidPartitionDomain(row.domain))
+            continue;
+        const prefix = partitionToken(row);
+        for (const value of row.domain) {
+            const token = slotToken(value);
+            slots.push({
+                partitionId: row.partitionId,
+                operation: row.operation,
+                axis: row.axis,
+                slotId: `${prefix}-${token}`,
+                kind: "each-value",
+                value,
+                intent: "nominal-filter",
+                expected: "domain-value",
+            });
+        }
+        if (row.optional) {
+            slots.push({
+                partitionId: row.partitionId,
+                operation: row.operation,
+                axis: row.axis,
+                slotId: `${prefix}-OMITTED`,
+                kind: "omitted",
+                value: "",
+                intent: "omitted",
+                expected: "default-behavior",
+            });
+        }
+        slots.push({
+            partitionId: row.partitionId,
+            operation: row.operation,
+            axis: row.axis,
+            slotId: `${prefix}-NOT-IN-SET`,
+            kind: "not-in-set",
+            value: "",
+            intent: "enum-invalid",
+            expected: row.complementExpected === "unknown" ? "GAP" : "complement",
+        });
+    }
+    return slots;
+}
+/**
+ * Bind parsed partitions to GET query/path OpenAPI axes.
+ * Unconfirmed axes keep identifier-valid Domain rows (requirement finite sets).
+ */
+export function applyOpenApiPartitionDomainPolicy(partitions, axes) {
+    const issues = [];
+    const valid = [];
+    for (const row of partitions) {
+        const operation = normalizePartitionOperation(row.operation);
+        const axisName = normalizePartitionAxisName(row.axis);
+        const matched = axes.find((axis) => normalizePartitionOperation(axis.operation) === operation &&
+            normalizePartitionAxisName(axis.name) === axisName);
+        if (!matched) {
+            valid.push(row);
+            continue;
+        }
+        if (matched.enumValues === null) {
+            issues.push(`NO_FINITE_DOMAIN: partition ${row.partitionId} axis ${row.axis} exists on ${row.operation} without a documented enum`);
+            continue;
+        }
+        if (!sameFiniteSet(matched.enumValues, row.domain)) {
+            issues.push(`PARTITION_SOURCE_MISMATCH: partition ${row.partitionId} domain does not match OpenAPI enum for ${row.operation} ${row.axis}`);
+            continue;
+        }
+        valid.push(row);
+    }
+    return { partitions: valid, issues };
+}
+/** Facts projection consumed by N6 and plan D gap-fill. */
+export const scenarioPartitionFactsSchema = z.object({
+    partitions: z.array(z.object({
+        partitionId: z.string(),
+        operation: z.string(),
+        axis: z.string(),
+        domain: z.array(z.string()),
+        optional: z.boolean(),
+        complementExpected: z.string(),
+        bindRule: z.string(),
+        slotIds: z.array(z.string()),
+    })),
+    slots: z.array(z.object({
+        slotId: z.string(),
+        partitionId: z.string(),
+        kind: z.string(),
+        intent: z.string(),
+        expected: z.string(),
+    })),
+    missingSlots: z.array(z.string()),
+});
+/**
+ * Compare expanded slots against the Case test-point universe. A slot is
+ * covered only when its exact slot ID is declared in some Case's 测试点 or
+ * binding lists. Missing each-value/omitted slots and the complement slot
+ * produce fail-closed finding codes; a GAP-expected complement that IS
+ * covered still reports a coverage gap (expected semantics undocumented).
+ */
+export function assessScenarioPartitionCoverage(partitions, declaredTestPointIds) {
+    const slots = expandScenarioPartitions(partitions);
+    const findings = [];
+    const missingSlots = [];
+    for (const row of partitions) {
+        const rowSlots = slots.filter((slot) => slot.partitionId === row.partitionId);
+        for (const slot of rowSlots) {
+            if (!declaredTestPointIds.has(slot.slotId)) {
+                missingSlots.push(slot.slotId);
+                const code = slot.kind === "not-in-set" ? "MISSING_COMPLEMENT_SLOT" : "MISSING_PARTITION_SLOT";
+                findings.push(`${code}: partition ${row.partitionId} slot ${slot.slotId} (${slot.kind}${slot.value ? `=${slot.value}` : ""}) is not covered by any Case test point`);
+            }
+            else if (slot.kind === "not-in-set" && slot.expected === "GAP") {
+                findings.push(`PARTITION_COMPLEMENT_EXPECTED_GAP: partition ${row.partitionId} complement slot ${slot.slotId} has no documented expected semantics in the bound source; expected stays GAP instead of guessing`);
+            }
+        }
+    }
+    return {
+        facts: {
+            partitions: partitions.map((row) => ({
+                partitionId: row.partitionId,
+                operation: row.operation,
+                axis: row.axis,
+                domain: row.domain,
+                optional: row.optional,
+                complementExpected: row.complementExpected,
+                bindRule: row.bindRule,
+                slotIds: slots
+                    .filter((slot) => slot.partitionId === row.partitionId)
+                    .map((slot) => slot.slotId),
+            })),
+            slots: slots.map((slot) => ({
+                slotId: slot.slotId,
+                partitionId: slot.partitionId,
+                kind: slot.kind,
+                intent: slot.intent,
+                expected: slot.expected,
+            })),
+            missingSlots,
+        },
+        findings,
+    };
+}

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

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
-import { isPriorityOnlyBackendTestModuleStem } from "./backend-test-module-stem.js";
+import { BACKEND_TEST_MAX_MODULE_COUNT, isOpaqueHashBackendTestModuleStem, isPriorityOnlyBackendTestModuleStem, } from "./backend-test-module-stem.js";
+import { resolveBackendTestLayout, } from "./backend-test-layout.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -103,6 +104,8 @@ function moduleStemInvalidReason(raw) {
     const stem = normalizeBackendTestModuleStem(raw);
     if (isPriorityOnlyBackendTestModuleStem(stem))
         return "priority-only-module-stem";
+    if (isOpaqueHashBackendTestModuleStem(stem))
+        return "opaque-hash-module-stem";
     if (stem.toLowerCase() === "readme")
         return "reserved-module-stem";
     if (!/^[a-z][a-z0-9_]*$/.test(stem))
@@ -114,28 +117,40 @@ function moduleStemInvalidReason(raw) {
 function looksLikeValidModuleStem(raw) {
     return moduleStemInvalidReason(raw) === undefined;
 }
-/** Inspect only authoritative README module-index candidates. */
-export function inspectModuleStemsFromReadme(readme) {
-    const candidates = [];
-    const tableRowLines = readme
+function extractCanonicalModuleIndexSection(readme) {
+    const lines = readme
         .replaceAll("\r\n", "\n")
         .replaceAll("\r", "\n")
-        .split("\n")
-        .filter((line) => line.includes("|"));
+        .split("\n");
+    const headings = lines.flatMap((line, index) => line.trim() === "## Module Index" ? [index] : []);
+    if (headings.length === 0) {
+        return { section: "", structureIssues: ["missing-module-index"] };
+    }
+    if (headings.length > 1) {
+        return { section: "", structureIssues: ["duplicate-module-index"] };
+    }
+    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;
+    return { section: lines.slice(start, end).join("\n"), structureIssues: [] };
+}
+/** Inspect only candidates inside the unique exact `## Module Index` section. */
+export function inspectModuleStemsFromReadme(readme) {
+    const extracted = extractCanonicalModuleIndexSection(readme);
+    const candidates = [];
+    const tableRowLines = extracted.section.split("\n").filter((line) => line.includes("|"));
     for (const line of tableRowLines) {
         for (const match of line.matchAll(/`?testcase\/md\/([A-Za-z0-9_.-]+)\.md`?/g)) {
             candidates.push(match[1]);
         }
         for (const match of line.matchAll(/\|\s*`?([A-Za-z0-9_.-]+)`?\s*\|\s*`?testcase\/test_/g)) {
-            // This compatibility shape can also capture a numeric count column.
-            // Keep valid stems and the priority-only defect we diagnose, while
-            // ignoring non-stem incidental cells such as `1`.
-            if (looksLikeValidModuleStem(match[1]) || isPriorityOnlyBackendTestModuleStem(match[1])) {
-                candidates.push(match[1]);
+            const raw = match[1];
+            if (looksLikeValidModuleStem(raw) || moduleStemInvalidReason(raw) !== "invalid-syntax") {
+                candidates.push(raw);
             }
         }
     }
-    for (const match of readme.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
+    for (const match of extracted.section.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
         candidates.push(match[1]);
     }
     const uniqueCandidates = orderedUnique(candidates);
@@ -145,12 +160,18 @@ export function inspectModuleStemsFromReadme(readme) {
             ? [{ raw, normalized: normalizeBackendTestModuleStem(raw), reasonCode }]
             : [];
     });
+    const validStems = orderedUnique(uniqueCandidates
+        .filter(looksLikeValidModuleStem)
+        .map((stem) => normalizeBackendTestModuleStem(stem)));
+    const structureIssues = [...extracted.structureIssues];
+    if (validStems.length > BACKEND_TEST_MAX_MODULE_COUNT) {
+        structureIssues.push(`excessive-module-count: ${validStems.length} > ${BACKEND_TEST_MAX_MODULE_COUNT}`);
+    }
     return {
         candidates: uniqueCandidates,
-        validStems: orderedUnique(uniqueCandidates
-            .filter(looksLikeValidModuleStem)
-            .map((stem) => normalizeBackendTestModuleStem(stem))),
+        validStems,
         invalid,
+        structureIssues,
     };
 }
 /**
@@ -161,8 +182,9 @@ export function inspectModuleStemsFromReadme(readme) {
 export function extractModuleStemsFromReadme(readme) {
     return inspectModuleStemsFromReadme(readme).validStems;
 }
-async function listMarkdownModules(workspaceRoot) {
-    const root = path.join(workspaceRoot, "testcase", "md");
+async function listMarkdownModules(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const root = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
     if (!(await exists(root)))
         return [];
     const entries = await readdir(root, { withFileTypes: true });
@@ -170,7 +192,7 @@ async function listMarkdownModules(workspaceRoot) {
         .filter((entry) => entry.isFile() &&
         entry.name.toLowerCase().endsWith(".md") &&
         entry.name.toLowerCase() !== "readme.md")
-        .map((entry) => path.posix.join("testcase/md", entry.name.replaceAll("\\", "/"))));
+        .map((entry) => path.posix.join(resolved.markdownDir, entry.name.replaceAll("\\", "/"))));
 }
 /**
  * Recursively list `.py` file paths relative to `dirRoot` (forward slashes).
@@ -550,56 +572,58 @@ export async function assessBackendTestShardChildCompleteness(input) {
         issues,
     };
 }
-export async function assessBackendTestMdWriterCompleteness(workspaceRoot) {
+export async function assessBackendTestMdWriterCompleteness(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const readmeRel = resolved.readmePath;
     const issues = [];
-    const expectedPaths = ["testcase/md/README.md"];
+    const expectedPaths = [readmeRel];
     const actualPaths = [];
     const missingPaths = [];
     const brokenPaths = [];
-    const readmePath = path.join(workspaceRoot, "testcase", "md", "README.md");
+    const readmePath = path.join(workspaceRoot, ...readmeRel.split("/"));
     let readme = "";
     if (!(await exists(readmePath))) {
-        missingPaths.push("testcase/md/README.md");
+        missingPaths.push(readmeRel);
         issues.push({
             code: "T3",
-            path: "testcase/md/README.md",
+            path: readmeRel,
             detail: "README.md is missing",
             recoverable: true,
         });
     }
     else {
-        actualPaths.push("testcase/md/README.md");
+        actualPaths.push(readmeRel);
         readme = await readFile(readmePath, "utf8");
         if (!readme.includes("## Coverage Scope")) {
-            brokenPaths.push("testcase/md/README.md");
+            brokenPaths.push(readmeRel);
             issues.push({
                 code: "T5",
-                path: "testcase/md/README.md",
+                path: readmeRel,
                 detail: "README.md is missing ## Coverage Scope",
                 recoverable: true,
             });
         }
         if (!readme.includes("## Coverage Matrix") ||
             !hasMarkdownTable(readme, "Rule Key")) {
-            if (!brokenPaths.includes("testcase/md/README.md")) {
-                brokenPaths.push("testcase/md/README.md");
+            if (!brokenPaths.includes(readmeRel)) {
+                brokenPaths.push(readmeRel);
             }
             issues.push({
                 code: "T5",
-                path: "testcase/md/README.md",
+                path: readmeRel,
                 detail: "README.md Coverage Matrix table is missing or broken",
                 recoverable: true,
             });
         }
     }
     const indexedStems = extractModuleStemsFromReadme(readme);
-    const existingModules = await listMarkdownModules(workspaceRoot);
+    const existingModules = await listMarkdownModules(workspaceRoot, resolved);
     const existingByStem = new Map(existingModules.map((rel) => [
         normalizeBackendTestModuleStem(path.posix.basename(rel)),
         rel,
     ]));
     for (const stem of indexedStems) {
-        const rel = `testcase/md/${stem}.md`;
+        const rel = `${resolved.markdownDir}/${stem}.md`;
         expectedPaths.push(rel);
         const existing = existingByStem.get(stem);
         if (!existing) {
@@ -668,15 +692,16 @@ export async function assessBackendTestMdWriterCompleteness(workspaceRoot) {
         issues,
     };
 }
-export async function assessBackendTestPytestWriterCompleteness(workspaceRoot) {
+export async function assessBackendTestPytestWriterCompleteness(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
     const issues = [];
     const expectedPaths = [];
     const actualPaths = [];
     const missingPaths = [];
     const brokenPaths = [];
-    const modules = await listMarkdownModules(workspaceRoot);
+    const modules = await listMarkdownModules(workspaceRoot, resolved);
     for (const moduleRel of modules) {
-        const expected = expectedBackendTestPytestScriptForMarkdownModule(path.posix.basename(moduleRel));
+        const expected = expectedBackendTestPytestScriptForMarkdownModule(path.posix.basename(moduleRel), resolved);
         expectedPaths.push(expected);
         const absolute = path.join(workspaceRoot, expected);
         if (!(await exists(absolute))) {
@@ -836,6 +861,11 @@ export function isBackendTestCompletenessRetryCandidate(task) {
         task.id === "generate-backend-pytest-pi" ||
         task.id === "generate-backend-md-plan-pi" ||
         task.id === "generate-backend-pytest-plan-pi" ||
+        // Plan D gap-fill patch writers share the same Completeness Gate retry
+        // contract as full-chain writers.
+        task.id === "patch-backend-readme-matrix-pi" ||
+        (task.id?.startsWith("patch-backend-md-case-") ?? false) ||
+        (task.id?.startsWith("patch-backend-pytest-case-") ?? false) ||
         (task.id?.startsWith("generate-backend-md-case-") ?? false) ||
         (task.id?.startsWith("generate-backend-pytest-case-") ?? false));
 }
@@ -872,42 +902,44 @@ export function isBackendTestPytestPlanTask(task) {
  * index), WITHOUT requiring the indexed module files to exist yet — those are
  * written by the downstream map_agent shard children.
  */
-export async function assessBackendTestMdPlanCompleteness(workspaceRoot) {
+export async function assessBackendTestMdPlanCompleteness(workspaceRoot, layout) {
+    const resolvedPlan = layout ?? resolveBackendTestLayout(undefined);
+    const planReadmeRel = resolvedPlan.readmePath;
     const issues = [];
-    const expectedPaths = ["testcase/md/README.md"];
+    const expectedPaths = [planReadmeRel];
     const actualPaths = [];
     const missingPaths = [];
     const brokenPaths = [];
-    const readmePath = path.join(workspaceRoot, "testcase", "md", "README.md");
+    const readmePath = path.join(workspaceRoot, ...planReadmeRel.split("/"));
     if (!(await exists(readmePath))) {
-        missingPaths.push("testcase/md/README.md");
+        missingPaths.push(planReadmeRel);
         issues.push({
             code: "T3",
-            path: "testcase/md/README.md",
+            path: planReadmeRel,
             detail: "README.md is missing",
             recoverable: true,
         });
     }
     else {
-        actualPaths.push("testcase/md/README.md");
+        actualPaths.push(planReadmeRel);
         const readme = await readFile(readmePath, "utf8");
         if (!readme.includes("## Coverage Scope")) {
-            brokenPaths.push("testcase/md/README.md");
+            brokenPaths.push(planReadmeRel);
             issues.push({
                 code: "T5",
-                path: "testcase/md/README.md",
+                path: planReadmeRel,
                 detail: "README.md is missing ## Coverage Scope",
                 recoverable: true,
             });
         }
         if (!readme.includes("## Coverage Matrix") ||
             !hasMarkdownTable(readme, "Rule Key")) {
-            if (!brokenPaths.includes("testcase/md/README.md")) {
-                brokenPaths.push("testcase/md/README.md");
+            if (!brokenPaths.includes(planReadmeRel)) {
+                brokenPaths.push(planReadmeRel);
             }
             issues.push({
                 code: "T5",
-                path: "testcase/md/README.md",
+                path: planReadmeRel,
                 detail: "README.md Coverage Matrix table is missing or broken",
                 recoverable: true,
             });
@@ -917,24 +949,35 @@ export async function assessBackendTestMdPlanCompleteness(workspaceRoot) {
         // are produced by map_agent children and are NOT required here.
         const stemInspection = inspectModuleStemsFromReadme(readme);
         const indexedStems = stemInspection.validStems;
+        for (const structureIssue of stemInspection.structureIssues) {
+            if (!brokenPaths.includes(planReadmeRel)) {
+                brokenPaths.push(planReadmeRel);
+            }
+            issues.push({
+                code: "T5",
+                path: planReadmeRel,
+                detail: structureIssue,
+                recoverable: true,
+            });
+        }
         for (const invalid of stemInspection.invalid) {
-            if (!brokenPaths.includes("testcase/md/README.md")) {
-                brokenPaths.push("testcase/md/README.md");
+            if (!brokenPaths.includes(planReadmeRel)) {
+                brokenPaths.push(planReadmeRel);
             }
             issues.push({
                 code: "T5",
-                path: "testcase/md/README.md",
+                path: planReadmeRel,
                 detail: `${invalid.reasonCode}: ${invalid.normalized}; use a stable lowercase business resource/domain stem`,
                 recoverable: true,
             });
         }
         if (indexedStems.length === 0) {
-            if (!brokenPaths.includes("testcase/md/README.md")) {
-                brokenPaths.push("testcase/md/README.md");
+            if (!brokenPaths.includes(planReadmeRel)) {
+                brokenPaths.push(planReadmeRel);
             }
             issues.push({
                 code: "T5",
-                path: "testcase/md/README.md",
+                path: planReadmeRel,
                 detail: "README.md module index is empty; downstream map_agent has no stems to shard",
                 recoverable: true,
             });
@@ -960,16 +1003,17 @@ export async function assessBackendTestMdPlanCompleteness(workspaceRoot) {
  * requiring per-module pytest scripts to exist yet — those are written by the
  * downstream map_agent shard children.
  */
-export async function assessBackendTestPytestPlanCompleteness(workspaceRoot) {
+export async function assessBackendTestPytestPlanCompleteness(workspaceRoot, layout) {
+    const resolvedPlan = layout ?? resolveBackendTestLayout(undefined);
     const issues = [];
     const expectedPaths = [];
     const actualPaths = [];
     const missingPaths = [];
     const brokenPaths = [];
-    // Discover shared pytest resources under testcase/**/helpers/** and
-    // testcase/**/factories/** (the plan node writeSet globs).
+    // Discover shared pytest resources under <testRoot>/**/helpers/** and
+    // <testRoot>/**/factories/** (the plan node writeSet globs).
     const candidates = [];
-    for (const dir of ["testcase/helpers", "testcase/factories"]) {
+    for (const dir of [`${resolvedPlan.testRoot}/helpers`, `${resolvedPlan.testRoot}/factories`]) {
         const absolute = path.join(workspaceRoot, dir);
         if (await exists(absolute)) {
             for (const file of await listPythonFiles(absolute)) {

package/dist/workflows/dag/contract-output-registry.js

@@ -1,4 +1,19 @@
 import { structuredContractOutputSchemaIds, } from "./types.js";
+/**
+ * Registry of node-level structured contract validators, keyed by the
+ * `structuredContractOutput.schemaId` declared on a DAG task.
+ *
+ * The executor looks the validator up here instead of hardcoding per-contract
+ * imports, so new contracts (backend-test manifests, coverage contracts, ...)
+ * can opt into producing-node self-validation without touching the executor.
+ */
+export const structuredContractValidationClassifications = [
+    "format",
+    "schema",
+    "truncated",
+    "semantic-repair",
+    "governance-blocked",
+];
 const validators = new Map();
 export function registerStructuredContractValidator(schemaId, validator) {
     if (validators.has(schemaId)) {