@tea-agent/loop-agent 0.31.0 → 0.31.1

package/dist/workflows/dag/backend-test-pytest-collection.js

@@ -11,12 +11,16 @@ export const backendPytestCollectionFindingSchema = z.object({
     detail: z.string().min(1),
 }).strict();
 export const backendPytestCollectionFactsSchema = z.object({
-    schemaId: z.literal("backend-test-pytest-collection-v2"),
+    schemaId: z.literal("backend-test-pytest-collection-v3"),
     phase: z.enum(["initial", "final", "effective"]),
     status: z.enum(["PASS", "REPAIRABLE", "BLOCKED"]),
     repairEligible: z.boolean(),
     repairAttempt: z.number().int().min(0).max(1),
     collectionAttempted: z.boolean(),
+    fixtureResolutionAttempted: z.boolean(),
+    fixtureResolutionStatus: z.enum(["NOT_RUN", "PASS", "REPAIRABLE", "BLOCKED"]),
+    fixtureResolutionExitCode: z.number().int().nullable(),
+    repairPaths: z.array(z.string()),
     mappedScripts: z.array(z.string()).min(1),
     existingMappedScripts: z.array(z.string()),
     missingMappedScripts: z.array(z.string()),
@@ -28,17 +32,37 @@ export const backendPytestCollectionFactsSchema = z.object({
     findings: z.array(backendPytestCollectionFindingSchema),
     stdoutExcerpt: z.string(),
     stderrExcerpt: z.string(),
+    fixtureStdoutExcerpt: z.string(),
+    fixtureStderrExcerpt: z.string(),
     collectionSource: z.enum(["initial", "final"]).optional(),
 }).strict().superRefine((facts, context) => {
     if (facts.status === "PASS") {
-        if (!facts.collectionAttempted || facts.pytestExitCode !== 0 || facts.missingMappedScripts.length > 0 || facts.assetFiles.length === 0) {
-            context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest collection PASS requires attempted collection, exit 0, complete mapped scripts and bound assets" });
+        if (!facts.collectionAttempted || facts.pytestExitCode !== 0 || !facts.fixtureResolutionAttempted || facts.fixtureResolutionStatus !== "PASS" || facts.fixtureResolutionExitCode !== 0 || facts.missingMappedScripts.length > 0 || facts.assetFiles.length === 0) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest collection PASS requires collection and fixture-resolution PASS, complete mapped scripts and bound assets" });
         }
     }
     if (!facts.collectionAttempted && facts.pytestExitCode !== null) {
         context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest collection without an attempt cannot have an exit code" });
     }
+    if (!facts.fixtureResolutionAttempted && facts.fixtureResolutionExitCode !== null) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "backend pytest fixture resolution without an attempt cannot have an exit code" });
+    }
 });
+export const backendTestExecutionReadinessSchema = z.object({
+    schemaId: z.literal("backend-test-execution-readiness-v1"),
+    status: z.enum(["PASS", "PARTIAL", "BLOCKED"]),
+    collectionStatus: z.literal("PASS"),
+    fixtureResolutionStatus: z.literal("PASS"),
+    scenarioParamStatus: z.enum(["PASS", "PARTIAL", "FAIL", "UNAVAILABLE"]),
+    repairAttempts: z.object({
+        collection: z.number().int().min(0).max(1),
+        scenarioParam: z.number().int().min(0).max(1),
+    }).strict(),
+    mappedScripts: z.array(z.string()).min(1),
+    collectedItemIds: z.array(z.string()),
+    fixtureIssues: z.array(z.string()),
+    assetHashes: z.record(z.string(), z.string().regex(SHA256)),
+}).strict();
 function repoRef(workspaceRoot, absolutePath) {
     return path.relative(workspaceRoot, absolutePath).replaceAll(path.sep, "/");
 }
@@ -106,6 +130,28 @@ function collectionItems(stdout) {
             return /^testcase\//.test(line.replaceAll("\\", "/"));
         }).map((line) => line.replaceAll("\\", "/")))];
 }
+function testcasePythonPaths(output) {
+    return [...new Set((output.replaceAll("\\", "/").match(/testcase\/[A-Za-z0-9_./-]+\.py/gi) ?? []).map((item) => item.replace(/:\d+$/, "")))].sort();
+}
+function classifyFixtureResolutionFailure(output) {
+    const normalized = output.replaceAll("\\", "/");
+    const paths = testcasePythonPaths(normalized);
+    const generatedProviderPaths = paths.filter((item) => /testcase\/(?:helpers|factories)\//.test(item));
+    if (/fixture ['"][^'"]+['"] not found/i.test(normalized) && generatedProviderPaths.length > 0) {
+        return {
+            status: "REPAIRABLE",
+            kind: "missing-generated-fixture",
+            detail: "generated pytest fixture dependency or plugin registration is incomplete",
+            repairPaths: generatedProviderPaths,
+        };
+    }
+    return {
+        status: "BLOCKED",
+        kind: "unresolved-fixture-dependency",
+        detail: "fixture resolution failed without a safely attributable generated provider",
+        repairPaths: paths,
+    };
+}
 function classifyCollectionFailure(output) {
     const normalized = output.replaceAll("\\", "/");
     const blockedPatterns = [
@@ -134,14 +180,19 @@ function classifyCollectionFailure(output) {
 }
 export function assessBackendPytestCollection(input) {
     const items = collectionItems(input.stdout);
-    if (input.exitCode === 0) {
+    const fixtureResolution = input.fixtureResolution ?? { exitCode: 0, stdout: "fixture resolution assumed by direct assessor", stderr: "" };
+    if (input.exitCode === 0 && fixtureResolution.exitCode === 0) {
         return backendPytestCollectionFactsSchema.parse({
-            schemaId: "backend-test-pytest-collection-v2",
+            schemaId: "backend-test-pytest-collection-v3",
             phase: input.phase,
             status: "PASS",
             repairEligible: false,
             repairAttempt: input.phase === "final" ? 1 : 0,
             collectionAttempted: true,
+            fixtureResolutionAttempted: true,
+            fixtureResolutionStatus: "PASS",
+            fixtureResolutionExitCode: 0,
+            repairPaths: [],
             mappedScripts: input.inventory.mappedScripts,
             existingMappedScripts: input.inventory.mappedScripts,
             missingMappedScripts: [],
@@ -153,16 +204,55 @@ export function assessBackendPytestCollection(input) {
             findings: [],
             stdoutExcerpt: bounded(input.stdout),
             stderrExcerpt: bounded(input.stderr),
+            fixtureStdoutExcerpt: bounded(fixtureResolution.stdout),
+            fixtureStderrExcerpt: bounded(fixtureResolution.stderr),
+        });
+    }
+    if (input.exitCode === 0) {
+        const classification = classifyFixtureResolutionFailure(`${fixtureResolution.stdout}\n${fixtureResolution.stderr}`);
+        return backendPytestCollectionFactsSchema.parse({
+            schemaId: "backend-test-pytest-collection-v3",
+            phase: input.phase,
+            status: classification.status,
+            repairEligible: input.phase === "initial" && classification.status === "REPAIRABLE",
+            repairAttempt: input.phase === "final" ? 1 : 0,
+            collectionAttempted: true,
+            fixtureResolutionAttempted: true,
+            fixtureResolutionStatus: classification.status,
+            fixtureResolutionExitCode: fixtureResolution.exitCode,
+            repairPaths: classification.repairPaths,
+            mappedScripts: input.inventory.mappedScripts,
+            existingMappedScripts: input.inventory.mappedScripts,
+            missingMappedScripts: [],
+            assetFiles: input.inventory.assetFiles,
+            inputHashes: input.inventory.inputHashes,
+            pytestExitCode: input.exitCode,
+            collectedItemCount: items.length,
+            collectedItemIds: items,
+            findings: [{
+                    kind: classification.kind,
+                    classification: "test-asset-defect",
+                    repairability: classification.status === "REPAIRABLE" ? "repairable" : "blocked",
+                    detail: classification.detail,
+                }],
+            stdoutExcerpt: bounded(input.stdout),
+            stderrExcerpt: bounded(input.stderr),
+            fixtureStdoutExcerpt: bounded(fixtureResolution.stdout),
+            fixtureStderrExcerpt: bounded(fixtureResolution.stderr),
         });
     }
     const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`);
     return backendPytestCollectionFactsSchema.parse({
-        schemaId: "backend-test-pytest-collection-v2",
+        schemaId: "backend-test-pytest-collection-v3",
         phase: input.phase,
         status: classification.status,
         repairEligible: input.phase === "initial" && classification.status === "REPAIRABLE",
         repairAttempt: input.phase === "final" ? 1 : 0,
         collectionAttempted: true,
+        fixtureResolutionAttempted: false,
+        fixtureResolutionStatus: "NOT_RUN",
+        fixtureResolutionExitCode: null,
+        repairPaths: testcasePythonPaths(`${input.stdout}\n${input.stderr}`),
         mappedScripts: input.inventory.mappedScripts,
         existingMappedScripts: input.inventory.mappedScripts,
         missingMappedScripts: [],
@@ -179,16 +269,22 @@ export function assessBackendPytestCollection(input) {
             }],
         stdoutExcerpt: bounded(input.stdout),
         stderrExcerpt: bounded(input.stderr),
+        fixtureStdoutExcerpt: "",
+        fixtureStderrExcerpt: "",
     });
 }
 export function assessMissingBackendPytestScripts(input) {
     return backendPytestCollectionFactsSchema.parse({
-        schemaId: "backend-test-pytest-collection-v2",
+        schemaId: "backend-test-pytest-collection-v3",
         phase: "initial",
         status: "REPAIRABLE",
         repairEligible: true,
         repairAttempt: 0,
         collectionAttempted: false,
+        fixtureResolutionAttempted: false,
+        fixtureResolutionStatus: "NOT_RUN",
+        fixtureResolutionExitCode: null,
+        repairPaths: [...input.missingMappedScripts],
         mappedScripts: [...input.mappedScripts],
         existingMappedScripts: [...input.existingMappedScripts],
         missingMappedScripts: [...input.missingMappedScripts],
@@ -205,6 +301,8 @@ export function assessMissingBackendPytestScripts(input) {
         })),
         stdoutExcerpt: "",
         stderrExcerpt: "",
+        fixtureStdoutExcerpt: "",
+        fixtureStderrExcerpt: "",
     });
 }
 export function renderBackendPytestCollectionReport(facts) {
@@ -219,6 +317,10 @@ export function renderBackendPytestCollectionReport(facts) {
         `- Repair attempt: ${facts.repairAttempt}`,
         `- Collection attempted: ${facts.collectionAttempted}`,
         `- Pytest exit code: ${facts.pytestExitCode ?? "not-run"}`,
+        `- Fixture resolution attempted: ${facts.fixtureResolutionAttempted}`,
+        `- Fixture resolution status: ${facts.fixtureResolutionStatus}`,
+        `- Fixture resolution exit code: ${facts.fixtureResolutionExitCode ?? "not-run"}`,
+        `- Repair paths: ${facts.repairPaths.join(", ") || "none"}`,
         `- Mapped scripts: ${facts.mappedScripts.length}`,
         `- Existing mapped scripts: ${facts.existingMappedScripts.length}`,
         `- Missing mapped scripts: ${facts.missingMappedScripts.length}`,
@@ -245,6 +347,18 @@ export function renderBackendPytestCollectionReport(facts) {
         facts.stderrExcerpt,
         "```",
         "",
+        "## Fixture Resolution stdout",
+        "",
+        "```text",
+        facts.fixtureStdoutExcerpt,
+        "```",
+        "",
+        "## Fixture Resolution stderr",
+        "",
+        "```text",
+        facts.fixtureStderrExcerpt,
+        "```",
+        "",
     ].join("\n");
 }
 export async function writeBackendPytestCollectionArtifacts(input) {
@@ -289,6 +403,47 @@ function assertSameInventory(expected, actual) {
             throw new Error(`backend pytest collection hash drift: ${file}`);
     }
 }
+export async function materializeBackendTestExecutionReadiness(input) {
+    if (input.effective.phase !== "effective" || input.effective.status !== "PASS" || input.effective.fixtureResolutionStatus !== "PASS") {
+        throw new Error("backend-test execution readiness requires effective collection and fixture-resolution PASS");
+    }
+    const current = await buildBackendPytestAssetInventory(input.workspaceRoot, input.effective.mappedScripts);
+    assertSameInventory(input.effective, current);
+    const status = input.scenarioParamStatus === "FAIL"
+        ? "BLOCKED"
+        : input.scenarioParamStatus === "PASS"
+            ? "PASS"
+            : "PARTIAL";
+    const readiness = backendTestExecutionReadinessSchema.parse({
+        schemaId: "backend-test-execution-readiness-v1",
+        status,
+        collectionStatus: "PASS",
+        fixtureResolutionStatus: "PASS",
+        scenarioParamStatus: input.scenarioParamStatus,
+        repairAttempts: {
+            collection: input.effective.repairAttempt,
+            scenarioParam: input.scenarioParamRepairAttempt,
+        },
+        mappedScripts: input.effective.mappedScripts,
+        collectedItemIds: input.effective.collectedItemIds,
+        fixtureIssues: input.effective.findings.filter((item) => /fixture/i.test(item.kind)).map((item) => item.detail),
+        assetHashes: input.effective.inputHashes,
+    });
+    const contractsDir = path.join(input.runDir, "contracts");
+    await mkdir(contractsDir, { recursive: true });
+    await writeFile(path.join(contractsDir, "backend-test-execution-readiness.json"), `${JSON.stringify(readiness, null, 2)}\n`, "utf8");
+    return readiness;
+}
+export async function readBackendTestExecutionReadiness(filePath) {
+    return backendTestExecutionReadinessSchema.parse(JSON.parse(await readFile(filePath, "utf8")));
+}
+export async function assertBackendTestExecutionReadinessFresh(workspaceRoot, readiness) {
+    if (!["PASS", "PARTIAL"].includes(readiness.status)) {
+        throw new Error(`backend pytest execution readiness is ${readiness.status}`);
+    }
+    const current = await buildBackendPytestAssetInventory(workspaceRoot, readiness.mappedScripts);
+    assertSameInventory({ mappedScripts: readiness.mappedScripts, assetFiles: Object.keys(readiness.assetHashes), inputHashes: readiness.assetHashes }, current);
+}
 export async function assertBackendPytestCollectionFresh(workspaceRoot, effective) {
     if (effective.phase !== "effective" || effective.status !== "PASS") {
         throw new Error("backend pytest execution requires effective collection PASS facts");

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,
     });