@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,1030 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
+export const BACKEND_TEST_RESULT_SCHEMA_ID = "backend-test-result-v1";
+const SECRET_KEY = /(?:password|passwd|secret|token|api[_-]?key|private[_-]?key|credential|authorization)/i;
+const SECRET_VALUE = /(?:-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk|ghp|github_pat|xox[baprs]|AKIA)[-_A-Za-z0-9]{12,}\b)/;
+export const BACKEND_TEST_CLASSIFICATION_CATEGORIES = [
+    "ProductBug",
+    "TestBug",
+    "EnvFailure",
+    "ContractMismatch",
+    "FlakyTest",
+    "Unknown",
+];
+export const backendTestExecutionStatusSchema = z.enum([
+    "completed",
+    "collection-error",
+    "setup-error",
+    "teardown-error",
+    "command-error",
+    "report-error",
+]);
+export const backendTestCollectionStatusSchema = z.enum([
+    "ok",
+    "error",
+    "unknown",
+    "skipped",
+]);
+/**
+ * Task Pool consumable outcome tokens (frozen for M2; no auto follow-up).
+ * - passed: all executed tests green
+ * - completed-with-failures: process completed with assertion/test failures
+ * - collection-error: import/collection failures
+ * - command-error: runner/command could not complete normally
+ * - report-error: junit missing/corrupt after execution attempt
+ */
+export const backendTestOutcomeSchema = z.enum([
+    "passed",
+    "completed-with-failures",
+    "collection-error",
+    "setup-error",
+    "teardown-error",
+    "command-error",
+    "report-error",
+]);
+const junitRelativePathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !path.posix.isAbsolute(value) &&
+    !value.includes("\\") &&
+    value
+        .split("/")
+        .every((segment) => segment.length > 0 && segment !== "." && segment !== ".."), { message: "junit.relativePath must be a safe run-relative POSIX path" });
+const failureSummarySchema = z
+    .object({
+    classname: z.string().min(1),
+    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
+    .object({
+    schemaVersion: z.literal(1),
+    /** Process-level status of the pytest invocation. Task Pool: use with outcome. */
+    executionStatus: backendTestExecutionStatusSchema,
+    pytestExitCode: z.number().int().min(0).max(255),
+    collectionStatus: backendTestCollectionStatusSchema,
+    /** Total tests counted from JUnit (or 0 when report unavailable). */
+    tests: z.number().int().min(0),
+    passed: z.number().int().min(0),
+    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({
+        relativePath: junitRelativePathSchema,
+        sha256: z
+            .string()
+            .regex(/^[a-f0-9]{64}$/, "junit.sha256 must be lowercase hex sha256"),
+    })
+        .strict(),
+    /** Non-secret command summary only (no tokens/passwords). */
+    commandSummary: z.string().min(1),
+    /** Truncated failure/error summaries for Task Pool triage. */
+    failures: z.array(failureSummarySchema),
+    /**
+     * Authoritative shell-facing outcome for backend-test-outcome-gate-shell.
+     * Do not override from retrospective Markdown.
+     */
+    outcome: backendTestOutcomeSchema,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.tests !==
+        value.passed + value.failed + value.error + value.skipped) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "tests must equal passed+failed+error+skipped",
+            path: ["tests"],
+        });
+    }
+    if (SECRET_KEY.test(value.commandSummary) ||
+        SECRET_VALUE.test(value.commandSummary)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "commandSummary must not contain secret-like content",
+            path: ["commandSummary"],
+        });
+    }
+    for (const [index, failure] of value.failures.entries()) {
+        if (SECRET_VALUE.test(failure.message)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "failure message must not contain secret-like content",
+                path: ["failures", index, "message"],
+            });
+        }
+    }
+});
+const MAX_FAILURE_MESSAGE = 500;
+const MAX_FAILURES = 50;
+function decodeXmlEntities(value) {
+    return value
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, "&");
+}
+const XML_ATTR_PATTERNS = {
+    tests: /\btests\s*=\s*"([^"]*)"/i,
+    failures: /\bfailures\s*=\s*"([^"]*)"/i,
+    errors: /\berrors\s*=\s*"([^"]*)"/i,
+    skipped: /\bskipped\s*=\s*"([^"]*)"/i,
+    time: /\btime\s*=\s*"([^"]*)"/i,
+    classname: /\bclassname\s*=\s*"([^"]*)"/i,
+    name: /\bname\s*=\s*"([^"]*)"/i,
+    message: /\bmessage\s*=\s*"([^"]*)"/i,
+};
+function attr(tag, name) {
+    const pattern = XML_ATTR_PATTERNS[name];
+    if (!pattern)
+        return undefined;
+    const match = tag.match(pattern);
+    return match ? decodeXmlEntities(match[1] ?? "") : undefined;
+}
+function truncate(value, max = MAX_FAILURE_MESSAGE) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length <= max)
+        return normalized;
+    return `${normalized.slice(0, max - 1)}…`;
+}
+function assertNoSecrets(label, value) {
+    if (SECRET_KEY.test(value) || SECRET_VALUE.test(value)) {
+        throw new Error(`secret-like content rejected in ${label}`);
+    }
+}
+/**
+ * Minimal JUnit XML parser (no new npm deps). Fail-closed on non-JUnit markup.
+ */
+export function parseJunitXml(xml) {
+    const trimmed = xml.trim();
+    if (!trimmed) {
+        throw new Error("invalid junit xml: empty");
+    }
+    if (!/<testsuites\b/i.test(trimmed) && !/<testsuite\b/i.test(trimmed)) {
+        throw new Error("invalid junit xml: missing testsuites/testsuite root");
+    }
+    const hasSuitesRoot = /<testsuites\b/i.test(trimmed);
+    if ((hasSuitesRoot && !/<\/testsuites>\s*$/i.test(trimmed)) ||
+        (!hasSuitesRoot && !/<\/testsuite>\s*$/i.test(trimmed))) {
+        throw new Error("invalid junit xml: unclosed root element");
+    }
+    const openedCases = (trimmed.match(/<testcase\b/gi) ?? []).length;
+    const closedCases = (trimmed.match(/<\/testcase>/gi) ?? []).length;
+    const selfClosingCases = (trimmed.match(/<testcase\b[^>]*\/>/gi) ?? [])
+        .length;
+    if (openedCases !== closedCases + selfClosingCases) {
+        throw new Error("invalid junit xml: unclosed testcase element");
+    }
+    // Prefer root testsuites aggregates when present, then fall back to the first
+    // testsuite aggregate. Pytest commonly emits time only on <testsuite>.
+    const suitesOpen = trimmed.match(/<testsuites\b[^>]*>/i)?.[0];
+    const firstSuiteOpen = trimmed.match(/<testsuite\b[^>]*>/i)?.[0];
+    let tests = 0;
+    let failed = 0;
+    let errors = 0;
+    let skipped = 0;
+    let timeSec;
+    if (suitesOpen) {
+        const t = attr(suitesOpen, "tests");
+        const f = attr(suitesOpen, "failures");
+        const e = attr(suitesOpen, "errors");
+        const s = attr(suitesOpen, "skipped");
+        const time = attr(suitesOpen, "time");
+        if (t !== undefined)
+            tests = Number(t);
+        if (f !== undefined)
+            failed = Number(f);
+        if (e !== undefined)
+            errors = Number(e);
+        if (s !== undefined)
+            skipped = Number(s);
+        if (time !== undefined && time !== "")
+            timeSec = Number(time);
+    }
+    if (timeSec === undefined && firstSuiteOpen) {
+        const time = attr(firstSuiteOpen, "time");
+        if (time !== undefined && time !== "")
+            timeSec = Number(time);
+    }
+    // Self-closing first so empty cases ending with /> are not greedily paired with a later </testcase>.
+    const caseRe = /<testcase\b([^>]*?)\/>|<testcase\b([^>]*)>([\s\S]*?)<\/testcase>/gi;
+    const failures = [];
+    const cases = [];
+    let caseCount = 0;
+    let caseFailed = 0;
+    let caseErrors = 0;
+    let caseSkipped = 0;
+    let match = caseRe.exec(trimmed);
+    while (match !== null) {
+        caseCount += 1;
+        const openAttrs = match[1] ?? match[2] ?? "";
+        const body = match[3] ?? "";
+        const classname = attr(openAttrs, "classname") || "unknown";
+        const name = attr(openAttrs, "name") || "unknown";
+        const caseTime = attr(openAttrs, "time");
+        const caseDurationMs = caseTime !== undefined && caseTime !== "" && !Number.isNaN(Number(caseTime))
+            ? Math.round(Number(caseTime) * 1000)
+            : undefined;
+        const failureTag = body.match(/<failure\b([^>]*)>([\s\S]*?)<\/failure>|<failure\b([^>]*)\/>/i);
+        const errorTag = body.match(/<error\b([^>]*)>([\s\S]*?)<\/error>|<error\b([^>]*)\/>/i);
+        const skippedTag = /<skipped\b/i.test(body);
+        const caseStdout = body.match(/<system-out\b[^>]*>([\s\S]*?)<\/system-out>/i)?.[1];
+        const caseStderr = body.match(/<system-err\b[^>]*>([\s\S]*?)<\/system-err>/i)?.[1];
+        const capturedOutput = {
+            ...(caseStdout ? { stdout: decodeXmlEntities(caseStdout).trim() } : {}),
+            ...(caseStderr ? { stderr: decodeXmlEntities(caseStderr).trim() } : {}),
+        };
+        if (failureTag) {
+            caseFailed += 1;
+            const fAttrs = failureTag[1] ?? failureTag[3] ?? "";
+            const fBody = decodeXmlEntities(failureTag[2] ?? "").trim();
+            const message = decodeXmlEntities(attr(fAttrs, "message") || fBody || "failure");
+            const summary = truncate(message);
+            failures.push({
+                classname,
+                name,
+                message: summary,
+                kind: "failure",
+            });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "failure", message: summary, details: fBody || summary, ...capturedOutput });
+        }
+        else if (errorTag) {
+            caseErrors += 1;
+            const eAttrs = errorTag[1] ?? errorTag[3] ?? "";
+            const eBody = decodeXmlEntities(errorTag[2] ?? "").trim();
+            const message = decodeXmlEntities(attr(eAttrs, "message") || eBody || "error");
+            const summary = truncate(message);
+            failures.push({
+                classname,
+                name,
+                message: summary,
+                kind: "error",
+            });
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "error", message: summary, details: eBody || summary, ...capturedOutput });
+        }
+        else if (skippedTag) {
+            caseSkipped += 1;
+            const skippedAttrs = body.match(/<skipped\b([^>]*)/i)?.[1] ?? "";
+            const message = attr(skippedAttrs, "message");
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "skipped", ...(message ? { message } : {}), ...capturedOutput });
+        }
+        else {
+            cases.push({ classname, name, durationMs: caseDurationMs, status: "passed", ...capturedOutput });
+        }
+        match = caseRe.exec(trimmed);
+    }
+    // Prefer case-level facts when testcase elements exist; never trust root counters
+    // that hide <failure>/<error> children (fail-closed on contradictory aggregates).
+    if (caseCount > 0) {
+        if (suitesOpen) {
+            const declaredTests = attr(suitesOpen, "tests") !== undefined
+                ? Number(attr(suitesOpen, "tests"))
+                : undefined;
+            const declaredFailed = attr(suitesOpen, "failures") !== undefined
+                ? Number(attr(suitesOpen, "failures"))
+                : undefined;
+            const declaredErrors = attr(suitesOpen, "errors") !== undefined
+                ? Number(attr(suitesOpen, "errors"))
+                : undefined;
+            const declaredSkipped = attr(suitesOpen, "skipped") !== undefined
+                ? Number(attr(suitesOpen, "skipped"))
+                : undefined;
+            // pytest collection reports often use tests="0" with a synthetic error testcase.
+            // Always fail-closed when root counters under-report failure/error children.
+            if (declaredTests !== undefined &&
+                !Number.isNaN(declaredTests) &&
+                declaredTests !== caseCount) {
+                const collectionStyle = declaredTests === 0 && caseErrors > 0 && caseFailed === 0;
+                if (!collectionStyle) {
+                    throw new Error(`invalid junit xml: testsuites tests=${declaredTests} disagrees with testcase count=${caseCount}`);
+                }
+            }
+            if (declaredFailed !== undefined &&
+                !Number.isNaN(declaredFailed) &&
+                declaredFailed !== caseFailed) {
+                throw new Error(`invalid junit xml: testsuites failures=${declaredFailed} disagrees with case failures=${caseFailed}`);
+            }
+            if (declaredErrors !== undefined &&
+                !Number.isNaN(declaredErrors) &&
+                declaredErrors !== caseErrors) {
+                throw new Error(`invalid junit xml: testsuites errors=${declaredErrors} disagrees with case errors=${caseErrors}`);
+            }
+            if (declaredSkipped !== undefined &&
+                !Number.isNaN(declaredSkipped) &&
+                declaredSkipped !== caseSkipped) {
+                throw new Error(`invalid junit xml: testsuites skipped=${declaredSkipped} disagrees with case skipped=${caseSkipped}`);
+            }
+        }
+        tests = caseCount;
+        failed = caseFailed;
+        errors = caseErrors;
+        skipped = caseSkipped;
+    }
+    else if (!suitesOpen || Number.isNaN(tests) || tests === 0) {
+        // No testcase bodies: fall back to first testsuite attributes.
+        const suiteOpen = trimmed.match(/<testsuite\b[^>]*>/i)?.[0];
+        if (!suiteOpen) {
+            throw new Error("invalid junit xml: no testsuite data");
+        }
+        tests = Number(attr(suiteOpen, "tests") ?? "0");
+        failed = Number(attr(suiteOpen, "failures") ?? "0");
+        errors = Number(attr(suiteOpen, "errors") ?? "0");
+        skipped = Number(attr(suiteOpen, "skipped") ?? "0");
+        const time = attr(suiteOpen, "time");
+        if (time)
+            timeSec = Number(time);
+    }
+    if ([tests, failed, errors, skipped].some((n) => Number.isNaN(n) || n < 0)) {
+        throw new Error("invalid junit xml: non-numeric suite counters");
+    }
+    const passed = Math.max(0, tests - failed - errors - skipped);
+    return {
+        tests,
+        passed,
+        failed,
+        errors,
+        skipped,
+        durationMs: timeSec !== undefined && !Number.isNaN(timeSec)
+            ? Math.round(timeSec * 1000)
+            : undefined,
+        cases,
+        failures: failures.slice(0, MAX_FAILURES),
+    };
+}
+const HTML_ENTITY_MAP = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&apos;": "'",
+};
+/** Decode one HTML entity layer. Safe for the outer data-jsonblob attribute. */
+function decodeHtmlEntities(value) {
+    return value.replace(/&(?:amp|lt|gt|quot|apos|#\d+|#x[0-9a-f]+);/gi, (entity) => {
+        const named = HTML_ENTITY_MAP[entity.toLowerCase()];
+        if (named !== undefined)
+            return named;
+        const hex = entity.match(/^&#x([0-9a-f]+);$/i)?.[1];
+        const decimal = entity.match(/^&#(\d+);$/)?.[1];
+        const codePoint = hex
+            ? Number.parseInt(hex, 16)
+            : decimal
+                ? Number.parseInt(decimal, 10)
+                : Number.NaN;
+        return Number.isFinite(codePoint)
+            ? String.fromCodePoint(codePoint)
+            : entity;
+    });
+}
+/** Decode nested entities only after JSON parsing; bounded to avoid overwork. */
+function decodeHtmlEntitiesDeep(value) {
+    let current = value;
+    for (let index = 0; index < 3; index += 1) {
+        const decoded = decodeHtmlEntities(current);
+        if (decoded === current)
+            break;
+        current = decoded;
+    }
+    return current;
+}
+function parseDurationLabelMs(raw) {
+    if (!raw)
+        return undefined;
+    const value = Number.parseFloat(raw);
+    if (!Number.isFinite(value))
+        return undefined;
+    if (/\bms\b/i.test(raw))
+        return Math.round(value);
+    if (/\bsec|s\b/i.test(raw))
+        return Math.round(value * 1000);
+    // 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.
+ *
+ * pytest-html 4.x embeds the full report payload as an HTML-entity-escaped
+ * JSON string in `<div id="data-container" data-jsonblob="...">`. This helper
+ * locates that attribute, decodes entities and parses the JSON. Fail-closed on
+ * a non-pytest-html document so the pipeline never silently drops test facts.
+ */
+export function extractPytestHtmlReportData(html) {
+    const match = html.match(/id=["']data-container["'][^>]*data-jsonblob=["']([^"']*)["']/i);
+    if (!match || !match[1]) {
+        throw new Error("invalid pytest-html report: missing data-container data-jsonblob island");
+    }
+    const decoded = decodeHtmlEntities(match[1]);
+    try {
+        return JSON.parse(decoded);
+    }
+    catch (error) {
+        throw new Error(`invalid pytest-html report: data-jsonblob is not valid JSON (${error instanceof Error ? error.message : String(error)})`);
+    }
+}
+/**
+ * Parse a self-contained pytest-html 4.x report into the same ParsedJunit
+ * shape used by the HTML/facts renderers, so the downstream rendering path
+ * stays uniform regardless of the evidence source.
+ *
+ * Unlike JUnit, pytest-html stores per-test captured stdout in a `log` field
+ * (with section markers like "Captured stdout call"). We surface that as the
+ * case `stdout` so HTTP_REQUEST/HTTP_RESPONSE lines remain visible in the
+ * per-case cards.
+ */
+export function parsePytestHtmlReport(html) {
+    const data = extractPytestHtmlReportData(html);
+    const entries = Object.entries(data.tests ?? {});
+    if (entries.length === 0) {
+        throw new Error("invalid pytest-html report: no test entries in data-jsonblob");
+    }
+    const cases = [];
+    const failures = [];
+    let passed = 0;
+    let failed = 0;
+    let errors = 0;
+    let skipped = 0;
+    for (const [nodeId, records] of entries) {
+        const record = records[0];
+        if (!record)
+            continue;
+        const rawResult = (record.result ?? "").toLowerCase();
+        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 decodedCapturedLog = decodeHtmlEntitiesDeep(capturedLog);
+        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({ ...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", 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", 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({ ...baseCase, status: "skipped", ...(stdout ? { stdout } : {}), ...(stderr ? { stderr } : {}) });
+        }
+        else {
+            errors += 1;
+            const message = `unexpected pytest-html result label: ${record.result ?? "(empty)"}`;
+            const summary = truncate(message);
+            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;
+    return {
+        tests,
+        passed,
+        failed,
+        errors,
+        skipped,
+        durationMs: undefined,
+        cases,
+        failures: failures.slice(0, MAX_FAILURES),
+    };
+}
+/**
+ * Split a pytest node id into module classname, test name, and optional file path.
+ *
+ * Handles:
+ * - `testcase/test_x.py::test_name`
+ * - `testcase/test_x.py::TestClass::test_name` (class-based; previous code
+ *   treated `TestClass` as the file segment and later filtered it to unknown.py)
+ * - Windows separators and parametrized names `test_name[param]`
+ */
+export function splitPytestNodeId(testId) {
+    const normalized = testId.replaceAll("\\", "/").trim();
+    if (!normalized) {
+        return { classname: "unknown", name: "unknown" };
+    }
+    const parts = normalized.split("::").filter(Boolean);
+    if (parts.length < 2) {
+        // Bare id without "::" — keep as name; path unknown.
+        return { classname: "unknown", name: normalized };
+    }
+    let rawName = parts[parts.length - 1];
+    // Drop call args if present; keep parametrize brackets in display name strip for id match.
+    const paren = rawName.indexOf("(");
+    if (paren >= 0)
+        rawName = rawName.slice(0, paren);
+    const cleanName = rawName.trim() || "unknown";
+    // Prefer the first segment that looks like a .py file path.
+    const filePart = parts.find((part) => /\.py$/i.test(part)) ??
+        (parts[0].includes("/") || parts[0].includes(".") ? parts[0] : undefined);
+    const filePath = filePart
+        ? filePart.replace(/\\/g, "/")
+        : undefined;
+    const moduleWithoutExt = (filePath ?? "unknown").replace(/\.py$/i, "");
+    const classname = moduleWithoutExt.replaceAll("/", ".") || "unknown";
+    return {
+        classname,
+        name: cleanName,
+        ...(filePath ? { filePath } : {}),
+    };
+}
+function splitPytestHtmlLogSections(log) {
+    if (!log)
+        return { stdout: "", stderr: "" };
+    // pytest-html HTML-entity-escapes the captured log content (e.g. `&quot;`
+    // for `"`). Decode entities first so downstream HTTP log parsers see the
+    // real JSON/kv payload rather than escaped markup.
+    const decoded = decodeHtmlEntitiesDeep(log);
+    // pytest-html interleaves captured stdout/stderr with section markers like
+    // "----------------------------- Captured stdout call -----------------------------".
+    // String.split includes capture-group matches in the result array, so the
+    // layout is [beforeText, label, body, label, body, ...]. Iterate label/body
+    // pairs starting at index 1.
+    const sections = decoded.split(/^-+ Captured (stdout|stderr|log|call|setup|teardown)(?: call| setup| teardown)? -+$/m);
+    let stdout = "";
+    let stderr = "";
+    for (let index = 1; index < sections.length - 1; index += 2) {
+        const label = sections[index]?.toLowerCase() ?? "";
+        const body = sections[index + 1] ?? "";
+        if (label.includes("stderr")) {
+            stderr = `${stderr}${body}`.trim();
+        }
+        else {
+            stdout = `${stdout}${body}`.trim();
+        }
+    }
+    if (!stdout && !stderr) {
+        // No recognizable section markers: treat the whole log as stdout so HTTP
+        // request/response lines remain visible.
+        stdout = decoded.trim();
+    }
+    return { stdout, stderr };
+}
+function extractPytestHtmlFailureMessage(log) {
+    if (!log)
+        return "";
+    const decoded = decodeHtmlEntitiesDeep(log);
+    // pytest-html failure logs contain assertion lines prefixed with "E   " and a
+    // trailing location line like "test_x.py:N: AssertionError". Prefer the
+    // explicit AssertionError/Error line; fall back to the last "E   " line.
+    const assertionLine = decoded
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => /:\s*AssertionError/.test(line));
+    if (assertionLine)
+        return assertionLine.replace(/^.*?:\s*/, "");
+    const eLines = decoded
+        .split(/\r?\n/)
+        .filter((line) => /^E\s+/.test(line))
+        .map((line) => line.replace(/^E\s+/, "").trim());
+    if (eLines.length > 0)
+        return eLines[eLines.length - 1];
+    return "";
+}
+export function deriveBackendTestResult(input) {
+    assertNoSecrets("commandSummary", input.commandSummary);
+    const emptyJunitMeta = {
+        relativePath: input.junitRelativePath,
+        sha256: "0".repeat(64),
+    };
+    if (input.junitXml === null || input.junitXml === undefined) {
+        if (!input.allowMissingJunit) {
+            throw new Error("missing junit report");
+        }
+        const outcome = input.pytestExitCode === 0 ? "report-error" : "command-error";
+        const executionStatus = input.pytestExitCode === 0 ? "report-error" : "command-error";
+        const result = {
+            schemaVersion: 1,
+            executionStatus,
+            pytestExitCode: input.pytestExitCode,
+            collectionStatus: "unknown",
+            tests: 0,
+            passed: 0,
+            failed: 0,
+            error: 0,
+            skipped: 0,
+            collectedItemCount: 0,
+            setupStartedCount: 0,
+            businessTestBodyExecutedCount: 0,
+            setupErrorCount: 0,
+            testFailureCount: 0,
+            teardownErrorCount: 0,
+            junit: emptyJunitMeta,
+            commandSummary: input.commandSummary,
+            failures: [],
+            outcome,
+        };
+        return backendTestResultContractSchema.parse(result);
+    }
+    let parsed;
+    try {
+        parsed = parseJunitXml(input.junitXml);
+    }
+    catch (error) {
+        throw new Error(`invalid junit xml: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    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";
+    const looksLikeCollection = exit === 2 ||
+        parsed.failures.some((f) => f.kind === "error" &&
+            /collect|import|syntax/i.test(`${f.name} ${f.message}`));
+    if (looksLikeCollection && (parsed.errors > 0 || exit >= 2)) {
+        executionStatus = "collection-error";
+        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";
+        outcome = "command-error";
+    }
+    else if (parsed.failed > 0 || parsed.errors > 0 || exit === 1) {
+        executionStatus = "completed";
+        collectionStatus = "ok";
+        outcome = "completed-with-failures";
+    }
+    else if (exit === 0 && parsed.failed === 0 && parsed.errors === 0) {
+        executionStatus = "completed";
+        collectionStatus = "ok";
+        outcome = "passed";
+    }
+    else {
+        executionStatus = "command-error";
+        collectionStatus = "unknown";
+        outcome = "command-error";
+    }
+    const result = {
+        schemaVersion: 1,
+        executionStatus,
+        pytestExitCode: exit,
+        collectionStatus,
+        tests: parsed.tests,
+        passed: parsed.passed,
+        failed: parsed.failed,
+        error: parsed.errors,
+        skipped: parsed.skipped,
+        ...executionCounts,
+        durationMs: parsed.durationMs,
+        junit: {
+            relativePath: input.junitRelativePath,
+            sha256,
+        },
+        commandSummary: input.commandSummary,
+        failures: parsed.failures.map((f) => ({
+            classname: f.classname || "unknown",
+            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,
+    };
+    return backendTestResultContractSchema.parse(result);
+}
+export function validateBackendTestResultJunitIntegrity(result, junitXml) {
+    backendTestResultContractSchema.parse(result);
+    const actualSha = createHash("sha256").update(junitXml).digest("hex");
+    if (result.junit.sha256 !== actualSha) {
+        throw new Error("junit sha256 mismatch against report content");
+    }
+}
+/**
+ * Deterministic classification constraints for Pi classifier (not the final label).
+ * Single-run failures must never suggest FlakyTest; collection/command never ProductBug.
+ */
+export function classifyCategoryHints(result) {
+    const forbidden = new Set();
+    const suggested = new Set();
+    // 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 (["collection-error", "setup-error", "teardown-error"].includes(result.executionStatus)) {
+            suggested.add("TestBug");
+        }
+        return {
+            suggestedCategories: [...suggested],
+            forbiddenCategories: [...forbidden],
+            confidenceCap: 0.6,
+        };
+    }
+    if (result.outcome === "passed") {
+        return {
+            suggestedCategories: [],
+            forbiddenCategories: [
+                ...forbidden,
+                "ProductBug",
+                "TestBug",
+                "EnvFailure",
+            ],
+            confidenceCap: 1,
+        };
+    }
+    // Assertion failures: ProductBug / TestBug / Unknown allowed; not Flaky.
+    suggested.add("ProductBug");
+    suggested.add("TestBug");
+    suggested.add("Unknown");
+    return {
+        suggestedCategories: [...suggested],
+        forbiddenCategories: [...forbidden],
+        confidenceCap: 0.75,
+    };
+}
+async function readPytestExitCode(runDir, fromNodeId, exitRelativePath = "reports/backend-test-pytest-exit.txt") {
+    const exitPath = path.join(runDir, ...exitRelativePath.split("/"));
+    try {
+        const raw = (await readFile(exitPath, "utf8")).trim();
+        const code = Number(raw);
+        if (raw !== "" && Number.isInteger(code) && code >= 0 && code <= 255)
+            return code;
+        throw new Error(`invalid pytest exit evidence at ${exitPath}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        // Missing dedicated evidence may fall through to an explicit node marker.
+    }
+    const nodePath = path.join(runDir, `${fromNodeId}.json`);
+    try {
+        const record = JSON.parse(await readFile(nodePath, "utf8"));
+        const blob = `${record.stdout ?? ""}\n${record.stderr ?? ""}`;
+        const marker = blob.match(/pytestExitCode\s*=\s*(\d{1,3})/i);
+        if (marker) {
+            const code = Number(marker[1]);
+            if (Number.isInteger(code) && code >= 0 && code <= 255)
+                return code;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw new Error("invalid pytest exit evidence in execute node record");
+        }
+    }
+    throw new Error("missing valid pytest exit evidence");
+}
+/**
+ * Materialize Result v1 from a pytest-html 4.x self-contained report (Markdown-first
+ * 8-node pipeline). `junit.relativePath` records the HTML path for integrity hashing
+ * (same field used historically for JUnit XML path).
+ */
+export async function materializeBackendTestResultFromPytestHtml(input) {
+    const htmlRelativePath = input.htmlRelativePath ?? "reports/backend-test.html";
+    const artifactName = input.artifactName ?? "backend-test-result.json";
+    const outputDir = input.outputDir ?? "contracts";
+    if (!/^[a-z0-9][a-z0-9._-]*\.json$/.test(artifactName) ||
+        !/^[a-z0-9][a-z0-9._-]*$/.test(outputDir)) {
+        throw new Error("unsafe structured artifact path");
+    }
+    let html = input.htmlContent;
+    if (html === undefined) {
+        const htmlAbs = path.join(input.runDir, ...htmlRelativePath.split("/"));
+        try {
+            html = await readFile(htmlAbs, "utf8");
+        }
+        catch {
+            throw new Error(`missing pytest-html report at ${htmlRelativePath} (fail-closed for Result v1)`);
+        }
+    }
+    if (!html.trim()) {
+        throw new Error("invalid pytest-html report: empty report");
+    }
+    let parsed;
+    try {
+        parsed = parsePytestHtmlReport(html);
+    }
+    catch (error) {
+        throw new Error(`invalid pytest-html report: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    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.failures.some((f) => f.kind === "error" &&
+            /collect|import|syntax/i.test(`${f.name} ${f.message}`));
+    if (looksLikeCollection && (parsed.errors > 0 || exit >= 2)) {
+        executionStatus = "collection-error";
+        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";
+        outcome = "command-error";
+    }
+    else if (parsed.failed > 0 || parsed.errors > 0 || exit === 1) {
+        executionStatus = "completed";
+        collectionStatus = "ok";
+        outcome = "completed-with-failures";
+    }
+    else if (exit === 0 && parsed.failed === 0 && parsed.errors === 0) {
+        executionStatus = "completed";
+        collectionStatus = "ok";
+        outcome = "passed";
+    }
+    else {
+        executionStatus = "command-error";
+        collectionStatus = "unknown";
+        outcome = "command-error";
+    }
+    const commandSummary = input.commandSummary ??
+        `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest -v -p no:cacheprovider --html=${htmlRelativePath} --self-contained-html`;
+    assertNoSecrets("commandSummary", commandSummary);
+    const result = backendTestResultContractSchema.parse({
+        schemaVersion: 1,
+        executionStatus,
+        pytestExitCode: exit,
+        collectionStatus,
+        tests: parsed.tests,
+        passed: parsed.passed,
+        failed: parsed.failed,
+        error: parsed.errors,
+        skipped: parsed.skipped,
+        ...executionCounts,
+        durationMs: parsed.durationMs,
+        junit: {
+            relativePath: htmlRelativePath,
+            sha256,
+        },
+        commandSummary,
+        failures: parsed.failures.map((f) => ({
+            classname: f.classname || "unknown",
+            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,
+    });
+    const relativePath = path.posix.join(outputDir, artifactName);
+    const artifactPath = await writeDagRunJsonArtifact(input.runDir, relativePath, result);
+    const serialized = `${JSON.stringify(result, null, 2)}\n`;
+    return {
+        path: artifactPath,
+        sha256: createHash("sha256").update(serialized).digest("hex"),
+        schemaId: BACKEND_TEST_RESULT_SCHEMA_ID,
+    };
+}
+export async function materializeBackendTestResultFromRunDir(input) {
+    if (!/^[a-z0-9][a-z0-9._-]*\.json$/.test(input.artifactName) ||
+        !/^[a-z0-9][a-z0-9._-]*$/.test(input.outputDir)) {
+        throw new Error("unsafe structured artifact path");
+    }
+    const junitRelativePath = input.junitRelativePath ?? "reports/backend-test-junit.xml";
+    const junitAbs = path.join(input.runDir, ...junitRelativePath.split("/"));
+    let junitXml = null;
+    try {
+        junitXml = await readFile(junitAbs, "utf8");
+    }
+    catch {
+        junitXml = null;
+    }
+    if (junitXml === null) {
+        throw new Error(`missing junit report at ${junitRelativePath} (fail-closed for Result v1)`);
+    }
+    if (!junitXml.trim()) {
+        throw new Error("invalid junit xml: empty report");
+    }
+    const pytestExitCode = await readPytestExitCode(input.runDir, input.fromNodeId, input.junitRelativePath?.endsWith("-junit.xml")
+        ? input.junitRelativePath.replace(/-junit\.xml$/, "-pytest-exit.txt")
+        : "reports/backend-test-pytest-exit.txt");
+    const commandSummary = `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest ${input.testRoot ?? "testcase"}/ -v -p no:cacheprovider --junitxml=${junitRelativePath}`;
+    let result;
+    try {
+        result = deriveBackendTestResult({
+            pytestExitCode,
+            junitXml,
+            junitRelativePath,
+            commandSummary,
+        });
+    }
+    catch (error) {
+        throw new Error(`invalid junit/report: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Integrity: stored sha must match bytes we read.
+    validateBackendTestResultJunitIntegrity(result, junitXml);
+    const relativePath = path.posix.join(input.outputDir, input.artifactName);
+    const artifactPath = await writeDagRunJsonArtifact(input.runDir, relativePath, result);
+    const serialized = `${JSON.stringify(result, null, 2)}\n`;
+    return {
+        path: artifactPath,
+        sha256: createHash("sha256").update(serialized).digest("hex"),
+        schemaId: BACKEND_TEST_RESULT_SCHEMA_ID,
+    };
+}
+/** Shell snippet for backend-test-outcome-gate-shell (result.outcome authoritative). */
+export function buildBackendTestOutcomeGateShellSnippet(options) {
+    const resultRelativePath = options?.resultRelativePath ?? "contracts/backend-test-result.json";
+    return [
+        'test -n "${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for backend-test outcome gate" >&2; exit 2; }',
+        `RESULT="\${HARNESS_DAG_RUN_DIR}/${resultRelativePath}"`,
+        'test -f "${RESULT}" || { echo "missing backend-test result: ${RESULT}" >&2; exit 2; }',
+        `node -e 'const fs=require("fs");const r=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));const outcome=String(r.outcome||"");const ok=outcome==="passed"&&Number(r.failed||0)===0&&Number(r.error||0)===0;console.log("backend-test outcome="+outcome+" passed="+r.passed+" failed="+r.failed+" error="+r.error+" executionStatus="+r.executionStatus);if(!ok){process.exit(1);}' "\${RESULT}"`,
+    ].join("; ");
+}