@tea-agent/loop-agent 0.30.0 → 0.31.1

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

@@ -17,6 +17,8 @@ export const BACKEND_TEST_CLASSIFICATION_CATEGORIES = [
 export const backendTestExecutionStatusSchema = z.enum([
     "completed",
     "collection-error",
+    "setup-error",
+    "teardown-error",
     "command-error",
     "report-error",
 ]);
@@ -38,6 +40,8 @@ export const backendTestOutcomeSchema = z.enum([
     "passed",
     "completed-with-failures",
     "collection-error",
+    "setup-error",
+    "teardown-error",
     "command-error",
     "report-error",
 ]);
@@ -55,6 +59,10 @@ const failureSummarySchema = z
     name: z.string().min(1),
     message: z.string().min(1),
     kind: z.enum(["failure", "error"]).default("failure"),
+    nodeId: z.string().min(1).optional(),
+    caseId: z.string().min(1).optional(),
+    tpId: z.string().min(1).optional(),
+    phase: z.enum(["collection", "setup", "call", "teardown", "unknown"]).optional(),
 })
     .strict();
 export const backendTestResultContractSchema = z
@@ -70,6 +78,12 @@ export const backendTestResultContractSchema = z
     failed: z.number().int().min(0),
     error: z.number().int().min(0),
     skipped: z.number().int().min(0),
+    collectedItemCount: z.number().int().min(0),
+    setupStartedCount: z.number().int().min(0),
+    businessTestBodyExecutedCount: z.number().int().min(0),
+    setupErrorCount: z.number().int().min(0),
+    testFailureCount: z.number().int().min(0),
+    teardownErrorCount: z.number().int().min(0),
     durationMs: z.number().nonnegative().optional(),
     junit: z
         .object({
@@ -403,6 +417,39 @@ function parseDurationLabelMs(raw) {
     // pytest-html commonly emits bare milliseconds without a unit suffix.
     return Math.round(value);
 }
+function canonicalPytestItemId(testId) {
+    return testId.replace(/::(?:setup|teardown)$/i, "");
+}
+function pytestHtmlPhase(testId, log) {
+    if (/::setup$/i.test(testId) || /ERROR at setup|Captured setup/i.test(log))
+        return "setup";
+    if (/::teardown$/i.test(testId) || /ERROR at teardown|Captured teardown/i.test(log))
+        return "teardown";
+    if (/collecting|ERROR collecting/i.test(log))
+        return "collection";
+    return "call";
+}
+function pytestFailureIdentity(nodeId) {
+    const caseToken = nodeId.match(/BE[-_][A-Z0-9_-]+[-_]\d{2,3}/i)?.[0];
+    const caseId = caseToken
+        ? caseToken.replace(/^BE_/i, "BE-").replaceAll("_", "-").toUpperCase()
+        : undefined;
+    const tpId = nodeId.match(/\[(TP-[A-Z0-9-]+)\]/i)?.[1]?.toUpperCase();
+    return { ...(caseId ? { caseId } : {}), ...(tpId ? { tpId } : {}) };
+}
+function parsedExecutionCounts(parsed) {
+    const setupErrorCount = parsed.cases.filter((item) => item.status === "error" && (item.phase === "setup" || /setup|fixture ['"][^'"]+['"] not found/i.test(`${item.name} ${item.message ?? ""} ${item.details ?? ""}`))).length;
+    const teardownErrorCount = parsed.cases.filter((item) => item.status === "error" && (item.phase === "teardown" || /teardown/i.test(`${item.name} ${item.message ?? ""} ${item.details ?? ""}`))).length;
+    const businessTestBodyExecutedCount = parsed.cases.filter((item) => item.status === "passed" || item.status === "failure" || (item.status === "error" && item.phase === "call" && !/fixture ['"][^'"]+['"] not found/i.test(`${item.message ?? ""} ${item.details ?? ""}`))).length;
+    return {
+        collectedItemCount: parsed.tests,
+        setupStartedCount: Math.max(0, parsed.tests - parsed.cases.filter((item) => item.phase === "collection").length),
+        businessTestBodyExecutedCount,
+        setupErrorCount,
+        testFailureCount: parsed.failed,
+        teardownErrorCount,
+    };
+}
 /**
  * Extract the pytest-html 4.x JSON island from a self-contained HTML report.
  *
@@ -451,93 +498,46 @@ export function parsePytestHtmlReport(html) {
         if (!record)
             continue;
         const rawResult = (record.result ?? "").toLowerCase();
-        const testId = record.testId ?? nodeId;
-        const { classname, name, filePath } = splitPytestNodeId(testId);
+        const rawTestId = record.testId ?? nodeId;
+        const capturedLog = record.log ?? "";
+        const phase = pytestHtmlPhase(rawTestId, capturedLog);
+        const canonicalNodeId = canonicalPytestItemId(nodeId.includes("::") ? nodeId : rawTestId);
+        const { classname, name, filePath } = splitPytestNodeId(canonicalNodeId);
+        const identity = pytestFailureIdentity(canonicalNodeId);
         const filePathFields = filePath ? { filePath } : {};
         const durationMs = parseDurationLabelMs(record.duration);
-        const capturedLog = record.log ?? "";
         const decodedCapturedLog = decodeHtmlEntitiesDeep(capturedLog);
-        // pytest-html collapses captured stdout/stderr into a single `log` field
-        // annotated with section markers. Preserve the whole log as stdout so the
-        // HTTP_REQUEST/HTTP_RESPONSE lines stay reachable for the per-case card.
         const stdout = splitPytestHtmlLogSections(capturedLog).stdout || undefined;
         const stderr = splitPytestHtmlLogSections(capturedLog).stderr || undefined;
+        const baseCase = { classname, name, nodeId: canonicalNodeId, phase, ...filePathFields, durationMs };
         if (rawResult === "passed") {
             passed += 1;
-            cases.push({
-                classname,
-                name,
-                ...filePathFields,
-                ...filePathFields,
-                durationMs,
-                status: "passed",
-                ...(stdout ? { stdout } : {}),
-                ...(stderr ? { stderr } : {}),
-            });
+            cases.push({ ...baseCase, status: "passed", ...(stdout ? { stdout } : {}), ...(stderr ? { stderr } : {}) });
         }
         else if (rawResult === "failed") {
             failed += 1;
             const message = extractPytestHtmlFailureMessage(capturedLog) || "failure";
             const summary = truncate(message);
-            failures.push({ classname, name, message: summary, kind: "failure" });
-            cases.push({
-                classname,
-                name,
-                ...filePathFields,
-                durationMs,
-                status: "failure",
-                message: summary,
-                details: decodedCapturedLog || summary,
-                ...(stdout ? { stdout } : {}),
-                ...(stderr ? { stderr } : {}),
-            });
+            failures.push({ classname, name, message: summary, kind: "failure", nodeId: canonicalNodeId, phase, ...identity });
+            cases.push({ ...baseCase, status: "failure", message: summary, details: decodedCapturedLog || summary, ...(stdout ? { stdout } : {}), ...(stderr ? { stderr } : {}) });
         }
         else if (rawResult === "error") {
             errors += 1;
             const message = extractPytestHtmlFailureMessage(capturedLog) || "error";
             const summary = truncate(message);
-            failures.push({ classname, name, message: summary, kind: "error" });
-            cases.push({
-                classname,
-                name,
-                ...filePathFields,
-                durationMs,
-                status: "error",
-                message: summary,
-                details: decodedCapturedLog || summary,
-                ...(stdout ? { stdout } : {}),
-                ...(stderr ? { stderr } : {}),
-            });
+            failures.push({ classname, name, message: summary, kind: "error", nodeId: canonicalNodeId, phase, ...identity });
+            cases.push({ ...baseCase, status: "error", message: summary, details: decodedCapturedLog || summary, ...(stdout ? { stdout } : {}), ...(stderr ? { stderr } : {}) });
         }
         else if (rawResult === "skipped" || rawResult === "xfailed") {
             skipped += 1;
-            cases.push({
-                classname,
-                name,
-                ...filePathFields,
-                durationMs,
-                status: "skipped",
-                ...(stdout ? { stdout } : {}),
-                ...(stderr ? { stderr } : {}),
-            });
+            cases.push({ ...baseCase, status: "skipped", ...(stdout ? { stdout } : {}), ...(stderr ? { stderr } : {}) });
         }
         else {
-            // Unknown outcome label: treat as error to stay fail-safe.
             errors += 1;
             const message = `unexpected pytest-html result label: ${record.result ?? "(empty)"}`;
             const summary = truncate(message);
-            failures.push({ classname, name, message: summary, kind: "error" });
-            cases.push({
-                classname,
-                name,
-                ...filePathFields,
-                durationMs,
-                status: "error",
-                message: summary,
-                details: decodedCapturedLog || summary,
-                ...(stdout ? { stdout } : {}),
-                ...(stderr ? { stderr } : {}),
-            });
+            failures.push({ classname, name, message: summary, kind: "error", nodeId: canonicalNodeId, phase, ...identity });
+            cases.push({ ...baseCase, status: "error", message: summary, details: decodedCapturedLog || summary, ...(stdout ? { stdout } : {}), ...(stderr ? { stderr } : {}) });
         }
     }
     const tests = cases.length;
@@ -666,6 +666,12 @@ export function deriveBackendTestResult(input) {
             failed: 0,
             error: 0,
             skipped: 0,
+            collectedItemCount: 0,
+            setupStartedCount: 0,
+            businessTestBodyExecutedCount: 0,
+            setupErrorCount: 0,
+            testFailureCount: 0,
+            teardownErrorCount: 0,
             junit: emptyJunitMeta,
             commandSummary: input.commandSummary,
             failures: [],
@@ -682,13 +688,11 @@ export function deriveBackendTestResult(input) {
     }
     const sha256 = createHash("sha256").update(input.junitXml).digest("hex");
     const exit = input.pytestExitCode;
+    const executionCounts = parsedExecutionCounts(parsed);
     let executionStatus = "completed";
     let collectionStatus = "ok";
     let outcome = "passed";
-    // Collection-heavy signals: pytest exit 2 is common for collection errors;
-    // also when error cases exist with zero/low completed tests.
     const looksLikeCollection = exit === 2 ||
-        (parsed.errors > 0 && parsed.passed + parsed.failed === 0) ||
         parsed.failures.some((f) => f.kind === "error" &&
             /collect|import|syntax/i.test(`${f.name} ${f.message}`));
     if (looksLikeCollection && (parsed.errors > 0 || exit >= 2)) {
@@ -696,6 +700,16 @@ export function deriveBackendTestResult(input) {
         collectionStatus = "error";
         outcome = "collection-error";
     }
+    else if (executionCounts.setupErrorCount > 0) {
+        executionStatus = "setup-error";
+        collectionStatus = "ok";
+        outcome = "setup-error";
+    }
+    else if (executionCounts.teardownErrorCount > 0) {
+        executionStatus = "teardown-error";
+        collectionStatus = "ok";
+        outcome = "teardown-error";
+    }
     else if (exit >= 2 && parsed.failed === 0 && parsed.errors === 0) {
         executionStatus = "command-error";
         collectionStatus = "unknown";
@@ -726,6 +740,7 @@ export function deriveBackendTestResult(input) {
         failed: parsed.failed,
         error: parsed.errors,
         skipped: parsed.skipped,
+        ...executionCounts,
         durationMs: parsed.durationMs,
         junit: {
             relativePath: input.junitRelativePath,
@@ -737,6 +752,10 @@ export function deriveBackendTestResult(input) {
             name: f.name || "unknown",
             message: truncate(f.message || "failure"),
             kind: f.kind,
+            ...(f.nodeId ? { nodeId: f.nodeId } : {}),
+            ...(f.caseId ? { caseId: f.caseId } : {}),
+            ...(f.tpId ? { tpId: f.tpId } : {}),
+            ...(f.phase ? { phase: f.phase } : {}),
         })),
         outcome,
     };
@@ -759,15 +778,19 @@ export function classifyCategoryHints(result) {
     // Single observation cannot prove flakiness.
     forbidden.add("FlakyTest");
     if (result.executionStatus === "collection-error" ||
+        result.executionStatus === "setup-error" ||
+        result.executionStatus === "teardown-error" ||
         result.executionStatus === "command-error" ||
         result.executionStatus === "report-error" ||
         result.outcome === "collection-error" ||
+        result.outcome === "setup-error" ||
+        result.outcome === "teardown-error" ||
         result.outcome === "command-error" ||
         result.outcome === "report-error") {
         forbidden.add("ProductBug");
         suggested.add("EnvFailure");
         suggested.add("Unknown");
-        if (result.executionStatus === "collection-error") {
+        if (["collection-error", "setup-error", "teardown-error"].includes(result.executionStatus)) {
             suggested.add("TestBug");
         }
         return {
@@ -865,11 +888,11 @@ export async function materializeBackendTestResultFromPytestHtml(input) {
     }
     const sha256 = createHash("sha256").update(html).digest("hex");
     const exit = input.pytestExitCode;
+    const executionCounts = parsedExecutionCounts(parsed);
     let executionStatus = "completed";
     let collectionStatus = "ok";
     let outcome = "passed";
     const looksLikeCollection = exit === 2 ||
-        (parsed.errors > 0 && parsed.passed + parsed.failed === 0) ||
         parsed.failures.some((f) => f.kind === "error" &&
             /collect|import|syntax/i.test(`${f.name} ${f.message}`));
     if (looksLikeCollection && (parsed.errors > 0 || exit >= 2)) {
@@ -877,6 +900,16 @@ export async function materializeBackendTestResultFromPytestHtml(input) {
         collectionStatus = "error";
         outcome = "collection-error";
     }
+    else if (executionCounts.setupErrorCount > 0) {
+        executionStatus = "setup-error";
+        collectionStatus = "ok";
+        outcome = "setup-error";
+    }
+    else if (executionCounts.teardownErrorCount > 0) {
+        executionStatus = "teardown-error";
+        collectionStatus = "ok";
+        outcome = "teardown-error";
+    }
     else if (exit >= 2 && parsed.failed === 0 && parsed.errors === 0) {
         executionStatus = "command-error";
         collectionStatus = "unknown";
@@ -910,6 +943,7 @@ export async function materializeBackendTestResultFromPytestHtml(input) {
         failed: parsed.failed,
         error: parsed.errors,
         skipped: parsed.skipped,
+        ...executionCounts,
         durationMs: parsed.durationMs,
         junit: {
             relativePath: htmlRelativePath,
@@ -921,6 +955,10 @@ export async function materializeBackendTestResultFromPytestHtml(input) {
             name: f.name || "unknown",
             message: truncate(f.message || "failure"),
             kind: f.kind,
+            ...(f.nodeId ? { nodeId: f.nodeId } : {}),
+            ...(f.caseId ? { caseId: f.caseId } : {}),
+            ...(f.tpId ? { tpId: f.tpId } : {}),
+            ...(f.phase ? { phase: f.phase } : {}),
         })),
         outcome,
     });

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

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
@@ -8,6 +9,7 @@ const factsSchema = z
     .object({
     schemaId: z.literal(BACKEND_TEST_SCENARIO_PARAM_FACTS_SCHEMA_ID),
     phase: z.enum(["initial", "final"]),
+    overallStatus: z.enum(["PASS", "PARTIAL", "FAIL", "UNAVAILABLE"]),
     repairEligible: z.boolean(),
     repairAttempt: z.number().int().min(0).max(1),
     strictScenarioParamGate: z.boolean(),
@@ -115,23 +117,28 @@ async function listMarkdownCases(workspaceRoot) {
 }
 export function inferScenarioParamIntent(input) {
     const { tpId, caseBody } = input;
-    const machineLine = /场景意图\s*[:：]\s*([a-z0-9+._-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(caseBody) ??
-        new RegExp(`${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,120}?intent\\s*[=:]\\s*([a-z0-9+._-]+)`, "i").exec(caseBody);
+    const preciseLine = /场景意图\s*[:：]\s*(TP-[A-Z0-9-]+)\s*[|;,，]\s*operation\s*=\s*([^|;,，\n]+)\s*[|;,，]\s*target\s*=\s*([A-Za-z0-9_.-]+)\s*[|;,，]\s*intent\s*=\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(caseBody);
+    const legacyLine = /场景意图\s*[:：]\s*([a-z0-9+._:-]+)(?:\s*[|;,，]\s*field\s*=\s*([A-Za-z0-9_.]+))?(?:\s*[|;,，]\s*bound\s*=\s*(\d+))?(?:\s*[|;,，]\s*example\s*=\s*([^|\n]+))?/i.exec(caseBody);
+    const fallbackLine = new RegExp(`${tpId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^\\n]{0,160}?intent\\s*[=:]\\s*([a-z0-9+._:-]+)`, "i").exec(caseBody);
+    const machineLine = preciseLine ?? legacyLine ?? fallbackLine;
     if (machineLine) {
-        const rawIntent = (machineLine[1] ?? "unknown").toLowerCase();
-        const field = machineLine[2];
-        const bound = machineLine[3] ? Number(machineLine[3]) : undefined;
-        const example = machineLine[4]?.trim();
-        if (rawIntent.startsWith("custom-literal:")) {
+        const rawIntent = (preciseLine ? preciseLine[4] : machineLine[1] ?? "unknown").toLowerCase();
+        const target = preciseLine?.[3];
+        const field = target && target !== "request" ? target.split(".").at(-1) : legacyLine?.[2];
+        const boundRaw = preciseLine?.[5] ?? legacyLine?.[3];
+        const example = (preciseLine?.[6] ?? legacyLine?.[4])?.trim();
+        const bound = boundRaw ? Number(boundRaw) : undefined;
+        const normalizedIntent = rawIntent === "nominal-operation" ? "nominal" : rawIntent;
+        if (normalizedIntent.startsWith("custom-literal:")) {
             return {
-                intent: rawIntent,
+                intent: normalizedIntent,
                 field,
                 bound,
                 example,
             };
         }
         return {
-            intent: (CLOSED_SET.has(rawIntent) ? rawIntent : "unknown"),
+            intent: (CLOSED_SET.has(normalizedIntent) ? normalizedIntent : "unknown"),
             field,
             bound,
             example,
@@ -240,6 +247,9 @@ export function observeParamFeatures(block, field) {
     // Prefer dict-like payload extraction.
     const dictMatch = /\{\s*([\s\S]*?)\s*\}/.exec(block) ??
         /(?:payload|body|data|json)\s*=\s*(\{[\s\S]*?\})/.exec(block);
+    if (dictMatch && !field) {
+        return { kind: "dict", text: (dictMatch[0] ?? dictMatch[1] ?? "{}").replace(/\s+/g, " ").slice(0, 160) };
+    }
     if (dictMatch && field) {
         const dict = dictMatch[0] ?? dictMatch[1] ?? "";
         const fieldPattern = new RegExp(`["']${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*:`);
@@ -531,19 +541,29 @@ export async function assessBackendScenarioParamConsistency(input) {
         });
     }
     const repairableCount = entries.filter((entry) => entry.repairability === "repairable" && entry.status === "MISMATCH").length;
+    const matchCount = entries.filter((entry) => entry.status === "MATCH").length;
+    const mismatchCount = entries.filter((entry) => entry.status === "MISMATCH").length;
+    const undeterminedCount = entries.filter((entry) => entry.status === "UNDETERMINED").length;
+    const overallStatus = mismatchCount > 0
+        ? "FAIL"
+        : matchCount === 0 && undeterminedCount > 0
+            ? "UNAVAILABLE"
+            : undeterminedCount > 0
+                ? "PARTIAL"
+                : "PASS";
     const facts = {
         schemaId: BACKEND_TEST_SCENARIO_PARAM_FACTS_SCHEMA_ID,
         phase: input.phase,
+        overallStatus,
         repairEligible: input.phase === "initial" && repairableCount > 0,
         repairAttempt: input.repairAttempt ?? (input.phase === "final" ? 1 : 0),
         strictScenarioParamGate: input.strictScenarioParamGate === true,
         entries,
         assetHashes,
         summary: {
-            matchCount: entries.filter((entry) => entry.status === "MATCH").length,
-            mismatchCount: entries.filter((entry) => entry.status === "MISMATCH")
-                .length,
-            undeterminedCount: entries.filter((entry) => entry.status === "UNDETERMINED").length,
+            matchCount,
+            mismatchCount,
+            undeterminedCount,
             repairableCount,
             blockedCount: entries.filter((entry) => entry.repairability === "blocked")
                 .length,
@@ -554,7 +574,7 @@ export async function assessBackendScenarioParamConsistency(input) {
         "",
         `## Status`,
         "",
-        facts.summary.mismatchCount > 0 ? "FAIL" : "PASS",
+        facts.overallStatus,
         "",
         `## Summary`,
         "",
@@ -615,10 +635,12 @@ function replaceFieldInDictLiteral(dictLiteral, field, mode, valueLiteral) {
     if (fieldPattern.test(dictLiteral)) {
         return dictLiteral.replace(fieldPattern, `$1$2${valueLiteral}`);
     }
-    // Insert before closing brace.
-    const trimmed = dictLiteral.replace(/\s*\}$/, "");
-    const needsComma = /:\s*[^,}\s][^}]*$/.test(trimmed);
-    return `${trimmed}${needsComma ? ", " : ""}${JSON.stringify(field)}: ${valueLiteral}}`;
+    // Insert before closing brace. Normalize an existing trailing comma first so
+    // adding a missing field can never produce `,,` and corrupt Python syntax.
+    const withoutClosingBrace = dictLiteral.replace(/\s*\}$/, "");
+    const trimmed = withoutClosingBrace.replace(/,\s*$/, "").trimEnd();
+    const hasEntries = trimmed.trim() !== "{";
+    return `${trimmed}${hasEntries ? ", " : ""}${JSON.stringify(field)}: ${valueLiteral}}`;
 }
 export function deterministicRewriteScenarioParam(input) {
     const { entry } = input;
@@ -693,6 +715,32 @@ export function deterministicRewriteScenarioParam(input) {
     }
     return { ok: true, source: nextSource, detail: "rewritten" };
 }
+function validatePythonSyntaxWithoutExecution(source) {
+    const result = spawnSync("python", ["-c", "import ast,sys; ast.parse(sys.stdin.read())"], {
+        input: source,
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            PYTHONDONTWRITEBYTECODE: "1",
+            PYTHONUTF8: "1",
+        },
+        timeout: 15_000,
+    });
+    if (result.error) {
+        return {
+            ok: false,
+            detail: `python syntax validation unavailable: ${result.error.message}`,
+        };
+    }
+    if (result.status !== 0) {
+        const detail = String(result.stderr || result.stdout || "invalid Python syntax")
+            .trim()
+            .replace(/\s+/g, " ")
+            .slice(0, 500);
+        return { ok: false, detail: `python syntax validation failed: ${detail}` };
+    }
+    return { ok: true, detail: "python ast.parse PASS" };
+}
 export async function applyDeterministicScenarioParamRepairs(input) {
     const repairable = input.facts.entries.filter((entry) => entry.status === "MISMATCH" && entry.repairability === "repairable");
     const byScript = new Map();
@@ -722,7 +770,7 @@ export async function applyDeterministicScenarioParamRepairs(input) {
             continue;
         }
         let source = await readFile(absolute, "utf8");
-        let fileChanged = false;
+        const staged = [];
         for (const entry of entries) {
             const result = deterministicRewriteScenarioParam({ source, entry });
             if (!result.ok) {
@@ -735,17 +783,31 @@ export async function applyDeterministicScenarioParamRepairs(input) {
                 continue;
             }
             source = result.source;
-            fileChanged = true;
-            repaired.push(entry.tpId);
-            auditEntries.push({
-                tpId: entry.tpId,
-                result: "rewritten",
-                detail: result.detail,
-            });
+            staged.push({ entry, detail: result.detail });
         }
-        if (fileChanged) {
+        if (staged.length > 0) {
+            const syntax = validatePythonSyntaxWithoutExecution(source);
+            if (!syntax.ok) {
+                for (const item of staged) {
+                    skipped.push({ tpId: item.entry.tpId, detail: syntax.detail });
+                    auditEntries.push({
+                        tpId: item.entry.tpId,
+                        result: "rolled-back-invalid-python",
+                        detail: syntax.detail,
+                    });
+                }
+                continue;
+            }
             await writeFile(absolute, source, "utf8");
             changedFiles.push(scriptPath);
+            for (const item of staged) {
+                repaired.push(item.entry.tpId);
+                auditEntries.push({
+                    tpId: item.entry.tpId,
+                    result: "rewritten",
+                    detail: `${item.detail}; ${syntax.detail}`,
+                });
+            }
         }
     }
     const afterHashes = [];
@@ -777,15 +839,15 @@ export async function writeScenarioParamRepairAudit(input) {
     return filePath;
 }
 export function renderBackendTestFailureAnalysis(input) {
-    const overviewNarrative = input.failed === 0
+    const overviewNarrative = input.failed + input.errors === 0
         ? "本轮无失败用例。报告仍保留场景-参数一致性与执行摘要，供审计。"
-        : `本轮共 ${input.failed} 个失败/错误用例。分类优先参考场景-参数一致性 final facts，再结合断言与环境证据。`;
+        : `本轮共 ${input.failed} 个失败用例、${input.errors} 个错误用例。分类优先参考场景-参数一致性 final facts，再结合断言与环境证据。`;
     return [
         "# 测试失败用例分析报告",
         "",
         `> 报告生成时间：${input.generatedAt}`,
         `> 测试报告来源：${input.htmlReportPath}`,
-        `> 测试总计：${input.total} 个用例（${input.passed} Passed, ${input.failed} Failed）`,
+        `> 测试总计：${input.total} 个用例（${input.passed} Passed, ${input.failed} Failed, ${input.errors} Error）`,
         `> 测试耗时：${input.durationLabel}`,
         `> 测试环境：${input.environmentSummary.split("\n")[0] ?? "unavailable"}`,
         `> 接口：${input.primaryOperation ?? "—"}`,

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

@@ -271,6 +271,39 @@ function pythonParseable(source) {
     // legal multi-line definitions such as `def f(\n    x,\n):` — removed.
     return true;
 }
+/**
+ * Forbidden generated shared helper/factory namespaces for the self-contained
+ * pytest module contract. A self-contained testcase/test_*.py child must not
+ * import from generated shared namespaces such as `testcase_helpers`,
+ * `testcase.helpers`, or `testcase.factories`; those belong to the pytest plan
+ * node's shared resources, not to a per-module pytest script. Rejecting such
+ * imports early (before pytest collection) gives an actionable, recoverable
+ * incomplete-write-set signal carrying the exact module target path.
+ */
+export const FORBIDDEN_GENERATED_IMPORT_NAMESPACES = [
+    "testcase_helpers",
+    "testcase.helpers",
+    "testcase.factories",
+];
+const FORBIDDEN_GENERATED_IMPORT_PATTERN = /^\s*(?:from\s+(testcase_helpers|testcase\.helpers|testcase\.factories)\b|import\s+(testcase_helpers|testcase\.helpers|testcase\.factories)\b)/gm;
+/**
+ * Scan Python source for imports from forbidden generated shared namespaces.
+ * Anchored at line start with a word boundary so `testcase.helpers_other` or a
+ * substring inside a docstring sentence is not falsely flagged. Returns the
+ * list of offending namespace module names (deduplicated, order-preserving).
+ */
+export function findForbiddenGeneratedImports(source) {
+    const hits = [];
+    const seen = new Set();
+    for (const match of source.matchAll(FORBIDDEN_GENERATED_IMPORT_PATTERN)) {
+        const ns = (match[1] ?? match[2]);
+        if (!seen.has(ns)) {
+            seen.add(ns);
+            hits.push(ns);
+        }
+    }
+    return hits;
+}
 /**
  * Looser Python validity check for shared helpers/factories emitted by the
  * pytest plan node. Unlike pythonParseable, it does NOT require balanced
@@ -417,6 +450,17 @@ export async function assessBackendTestShardChildCompleteness(input) {
                     recoverable: true,
                 });
             }
+            const forbidden = findForbiddenGeneratedImports(body);
+            if (forbidden.length > 0) {
+                if (!brokenPaths.includes(target))
+                    brokenPaths.push(target);
+                issues.push({
+                    code: "T5",
+                    path: target,
+                    detail: `forbidden import from ${forbidden.join(", ")} in ${target}; self-contained pytest module must not import generated shared helper/factory namespaces`,
+                    recoverable: true,
+                });
+            }
         }
     }
     const recoverableTargets = orderedUnique([...missingPaths, ...brokenPaths]);
@@ -584,6 +628,17 @@ export async function assessBackendTestPytestWriterCompleteness(workspaceRoot) {
             });
             continue;
         }
+        const forbidden = findForbiddenGeneratedImports(source);
+        if (forbidden.length > 0) {
+            brokenPaths.push(expected);
+            issues.push({
+                code: "T5",
+                path: expected,
+                detail: `forbidden import from ${forbidden.join(", ")} in ${expected}; self-contained pytest module must not import generated shared helper/factory namespaces`,
+                recoverable: true,
+            });
+            continue;
+        }
         const markdown = await readFile(path.join(workspaceRoot, moduleRel), "utf8");
         const caseIds = orderedUnique([...markdown.matchAll(/\bBE-[A-Z0-9_-]+-\d{2,3}\b/g)].map((item) => item[0]));
         const primaryHints = orderedUnique([