@kylecheng3146/agent-ops 0.5.2 → 0.6.0

package/dist/runtime/src/verify/adapters/jest.js

@@ -0,0 +1,142 @@
+import { parseJsonDocument, parseJsonLines, stableCheckId } from "../acceptance-protocol.js";
+import { array, hasRetry, lower, number, object, result, run, string } from "./shared.js";
+function reportFromInput(input) {
+    if (typeof input === "string") {
+        const document = parseJsonDocument(input);
+        if (object(document) !== undefined)
+            return { report: object(document), diagnostics: [] };
+        const lines = parseJsonLines(input);
+        if (lines.values.length === 1 && object(lines.values[0]) !== undefined) {
+            return { report: object(lines.values[0]), diagnostics: lines.invalidLines.map((line) => `invalid-json-line:${line}`) };
+        }
+        return { report: undefined, diagnostics: ["malformed-output", ...lines.invalidLines.map((line) => `invalid-json-line:${line}`)] };
+    }
+    return object(input) === undefined
+        ? { report: undefined, diagnostics: ["malformed-report"] }
+        : { report: object(input), diagnostics: [] };
+}
+function suiteResults(suite) {
+    return array(suite.assertionResults) ?? array(suite.assertions) ?? array(suite.tests) ?? [];
+}
+function suiteFile(suite) {
+    return string(suite.testFilePath ?? suite.filePath ?? suite.file ?? suite.name) ?? "<jest-suite>";
+}
+function assertionId(suite, assertion) {
+    const ancestors = array(assertion.ancestorTitles)
+        ?.filter((item) => typeof item === "string") ?? [];
+    // Jest's fullName already contains ancestorTitles; prefer the leaf title so
+    // real JSON reports and reporter events share one identity format.
+    const name = string(assertion.title ?? assertion.name) ??
+        (ancestors.length === 0 ? string(assertion.fullName) : undefined);
+    if (name === undefined)
+        return undefined;
+    const location = object(assertion.location);
+    const line = number(location?.line);
+    const column = number(location?.column);
+    try {
+        return stableCheckId([
+            suiteFile(suite),
+            ...ancestors,
+            name,
+            ...(line === undefined || column === undefined ? [] : [`@${line}:${column}`])
+        ]);
+    }
+    catch {
+        return undefined;
+    }
+}
+function infrastructure(suite, report) {
+    const present = (value) => value !== undefined && value !== null &&
+        (!Array.isArray(value) || value.length > 0);
+    if (present(suite.testExecError) || present(suite.runtimeError) ||
+        present(report.runExecError) || present(report.unhandledErrors) || present(report.errors) ||
+        report.wasInterrupted === true)
+        return true;
+    const runtimeSuites = number(report.numRuntimeErrorTestSuites);
+    return runtimeSuites !== undefined && runtimeSuites > 0;
+}
+function evidence(suite, id) {
+    const file = suiteFile(suite);
+    return [`jest:assertion:${file}:${id}`];
+}
+/** Collect a final Jest JSON report or an equivalent structured reporter document. */
+export function collectJestAcceptance(input, options) {
+    const parsed = reportFromInput(input);
+    const report = parsed.report;
+    if (report === undefined) {
+        return run(options, "jest", [], false, [], parsed.diagnostics);
+    }
+    const suites = array(report.testResults) ?? array(report.testFiles) ?? array(report.files);
+    if (suites === undefined) {
+        return run(options, "jest", [], false, [], [
+            ...parsed.diagnostics,
+            "missing-test-results"
+        ]);
+    }
+    const results = [];
+    const diagnostics = [...parsed.diagnostics];
+    for (const rawSuite of suites) {
+        const suite = object(rawSuite);
+        if (suite === undefined) {
+            diagnostics.push("malformed-suite");
+            continue;
+        }
+        const suiteHasInfrastructure = infrastructure(suite, report);
+        const assertions = suiteResults(suite);
+        if (assertions.length === 0 && suiteHasInfrastructure) {
+            diagnostics.push(`suite-infrastructure:${suiteFile(suite)}`);
+        }
+        for (const rawAssertion of assertions) {
+            const assertion = object(rawAssertion);
+            if (assertion === undefined) {
+                diagnostics.push(`malformed-assertion:${suiteFile(suite)}`);
+                continue;
+            }
+            const id = assertionId(suite, assertion);
+            if (id === undefined) {
+                diagnostics.push(`missing-check-id:${suiteFile(suite)}`);
+                continue;
+            }
+            const status = lower(assertion.status ?? assertion.state);
+            const observedAttempts = number(assertion.attempts ?? assertion.invocations);
+            const attemptCount = observedAttempts !== undefined && observedAttempts > 0 ? observedAttempts : null;
+            const evidenceRefs = evidence(suite, id);
+            const hooks = object(assertion.hooks);
+            const hookFailure = (Array.isArray(assertion.hookErrors) && assertion.hookErrors.length > 0) ||
+                (assertion.hookErrors !== undefined && assertion.hookErrors !== null && !Array.isArray(assertion.hookErrors)) ||
+                (hooks !== undefined && Object.values(hooks).some(state => state !== "pass" && state !== "passed"));
+            if (hasRetry(assertion)) {
+                results.push(result(options, "jest", id, "UNKNOWN", evidenceRefs, "retry", attemptCount));
+            }
+            else if (suiteHasInfrastructure) {
+                results.push(result(options, "jest", id, "UNKNOWN", evidenceRefs, "infrastructure-error", attemptCount));
+            }
+            else if (hookFailure) {
+                results.push(result(options, "jest", id, "UNKNOWN", evidenceRefs, "hook-error", attemptCount));
+            }
+            else if (status === "passed" || status === "pass") {
+                results.push(result(options, "jest", id, "PASS", evidenceRefs, "none", attemptCount));
+            }
+            else if (status === "failed" || status === "fail") {
+                // Native Jest JSON does not distinguish a test-call assertion from an
+                // assertion thrown by before/after hooks. Only classified collector
+                // metadata can establish behavioral red; failureMessages cannot.
+                const assertionFailure = assertion.assertion === true || assertion.failureClass === "assertion-failed";
+                results.push(assertionFailure
+                    ? result(options, "jest", id, "FAIL", evidenceRefs, "assertion-failed", attemptCount)
+                    : result(options, "jest", id, "UNKNOWN", evidenceRefs, "infrastructure-error", attemptCount));
+            }
+            else if (status === "pending" || status === "todo" || status === "skipped" || status === "disabled") {
+                results.push(result(options, "jest", id, "UNKNOWN", evidenceRefs, status === "todo" ? "todo" : "skipped", attemptCount));
+            }
+            else {
+                results.push(result(options, "jest", id, "UNKNOWN", evidenceRefs, "malformed-output", attemptCount));
+            }
+        }
+    }
+    if ((report.success === false || (number(report.numFailedTestSuites) ?? 0) > 0) &&
+        !results.some(item => item.status !== "PASS"))
+        diagnostics.push("unexplained-failed-report");
+    const completed = report.completed !== false && report.interrupted !== true;
+    return run(options, "jest", results, completed, completed ? ["jest:report:complete"] : [], diagnostics);
+}

package/dist/runtime/src/verify/adapters/node-reporter.js

@@ -0,0 +1,20 @@
+/** JSONL reporter for node --test; preserves assertion Error metadata. */
+function errorData(value, seen = new Set()) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (seen.has(value))
+        return "[circular]";
+    seen.add(value);
+    if (value instanceof Error)
+        return { name: value.name,
+            code: value.code,
+            failureType: value.failureType,
+            cause: errorData(value.cause, seen) };
+    if (Array.isArray(value))
+        return value.map(item => errorData(item, seen));
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, errorData(item, seen)]));
+}
+export default async function* nodeAcceptanceReporter(events) {
+    for await (const event of events)
+        yield JSON.stringify(errorData(event)) + "\n";
+}

package/dist/runtime/src/verify/adapters/node.js

@@ -0,0 +1,254 @@
+import { resolve } from "node:path";
+import { parseJsonDocument, parseJsonLines, stableCheckId } from "../acceptance-protocol.js";
+import { attempts, hasRetry, lower, object, result, run, string, terminal, terminalEvidence } from "./shared.js";
+function eventsFromInput(input) {
+    if (typeof input !== "string")
+        return { events: input, diagnostics: [] };
+    const document = parseJsonDocument(input);
+    if (Array.isArray(document))
+        return { events: document, diagnostics: [] };
+    const lines = parseJsonLines(input);
+    if (lines.values.length > 0 || lines.invalidLines.length > 0) {
+        return {
+            events: lines.values,
+            diagnostics: lines.invalidLines.map((line) => `invalid-json-line:${line}`)
+        };
+    }
+    return document === undefined
+        ? { events: [], diagnostics: ["malformed-output"] }
+        : { events: Array.isArray(document) ? document : [document], diagnostics: [] };
+}
+function eventData(value) {
+    return object(value.data) ?? value;
+}
+function eventType(value) {
+    return lower(value.type ?? value.event ?? value.kind);
+}
+function checkId(data) {
+    const file = string(data.file ?? data.filePath ?? data.filename);
+    const ancestors = Array.isArray(data.ancestorNames)
+        ? data.ancestorNames.filter((item) => typeof item === "string")
+        : Array.isArray(data.nesting)
+            ? data.nesting.filter((item) => typeof item === "string")
+            : Array.isArray(data.ancestorTitles)
+                ? data.ancestorTitles.filter((item) => typeof item === "string")
+                : [];
+    const name = string(data.name ?? data.title ?? data.fullName);
+    if (name === undefined)
+        return undefined;
+    const line = typeof data.line === "number" && Number.isSafeInteger(data.line) ? data.line : undefined;
+    const column = typeof data.column === "number" && Number.isSafeInteger(data.column) ? data.column : undefined;
+    try {
+        return stableCheckId([
+            file ?? "<node-test>",
+            ...ancestors,
+            name,
+            ...(line === undefined || column === undefined ? [] : [`@${line}:${column}`])
+        ]);
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertionFailure(data) {
+    if (nonAssertionFailure(data) !== undefined)
+        return false;
+    if (data.assertion === true || data.isAssertion === true)
+        return true;
+    const explicit = lower(data.failureClass ?? data.failureKind ?? data.errorType);
+    if (explicit === "assertion" || explicit === "assertion-failed" || explicit === "test-assertion") {
+        return true;
+    }
+    const details = object(data.details);
+    const error = object(data.error) ?? object(details?.error);
+    const cause = object(error?.cause);
+    const errorName = lower(error?.name ?? error?.type);
+    const errorCode = lower(error?.code);
+    const causeName = lower(cause?.name ?? cause?.type);
+    const causeCode = lower(cause?.code);
+    return errorName === "assertionerror" || errorCode === "err_assertion" ||
+        causeName === "assertionerror" || causeCode === "err_assertion";
+}
+function nonAssertionFailure(data) {
+    const details = object(data.details);
+    const kind = lower(data.kind ?? data.scope ?? data.type ?? details?.type);
+    if (kind === "hook")
+        return "hook-error";
+    if (kind === "fixture")
+        return "fixture-error";
+    if (kind === "collection" || kind === "root" || kind === "suite")
+        return "collection-error";
+    if (data.timeout === true)
+        return "timeout";
+    const error = object(data.error) ?? object(details?.error);
+    const nativeFailure = lower(error?.failureType);
+    if (nativeFailure === "hookfailed")
+        return "hook-error";
+    if (nativeFailure === "testtimeoutfailure")
+        return "timeout";
+    if (nativeFailure === "cancelledbyparent" || nativeFailure === "testaborted")
+        return "cancelled";
+    if (nativeFailure !== undefined && nativeFailure !== "testcodefailure")
+        return "infrastructure-error";
+    const explicit = lower(data.failureClass ?? data.failureKind ?? data.errorType);
+    if (explicit !== undefined && !["assertion", "assertion-failed", "test-assertion"].includes(explicit)) {
+        return explicit;
+    }
+    return undefined;
+}
+function eventEvidence(type, data, id) {
+    const sequence = string(data.sequence ?? data.id ?? data.testId);
+    return [`node:${type}:${id}`, ...(sequence === undefined ? [] : [`sequence:${sequence}`])];
+}
+/** Collect node:test TestsStream/custom reporter events without parsing stdout text. */
+export function collectNodeAcceptance(input, options) {
+    const parsed = eventsFromInput(input);
+    const results = [];
+    const seenCheckIds = new Set();
+    const duplicateCheckIds = new Set();
+    const pendingComplete = new Map();
+    const diagnostics = [...parsed.diagnostics];
+    let completed = false;
+    let failedSummary = false;
+    let completionEvidence = [];
+    // start/pass/fail follow definition order, even for concurrent suites.
+    // Execution-ordered complete events cannot supply unambiguous lineage.
+    const stacks = new Map();
+    const append = (id, data, evidence, attemptCount, passed) => {
+        const failure = hasRetry(data) ? "retry" : (data.skip === true || typeof data.skip === "string") ? "skipped"
+            : (data.todo === true || typeof data.todo === "string") ? "todo" : nonAssertionFailure(data);
+        results.push(failure !== undefined
+            ? result(options, "node:test", id, "UNKNOWN", evidence, failure, attemptCount)
+            : passed === true ? result(options, "node:test", id, "PASS", evidence, "none", attemptCount)
+                : passed === false && assertionFailure(data)
+                    ? result(options, "node:test", id, "FAIL", evidence, "assertion-failed", attemptCount)
+                    : result(options, "node:test", id, "UNKNOWN", evidence, passed === undefined ? "incomplete-output" : "infrastructure-error", attemptCount));
+        if (seenCheckIds.has(id))
+            duplicateCheckIds.add(id);
+        seenCheckIds.add(id);
+    };
+    for (const raw of parsed.events) {
+        const value = object(raw);
+        if (value === undefined) {
+            diagnostics.push("malformed-event");
+            continue;
+        }
+        const type = eventType(value);
+        const rawData = eventData(value);
+        const depth = rawData.nesting;
+        const rawFile = string(rawData.file);
+        const rawName = string(rawData.name);
+        let ancestors;
+        if (typeof depth === "number" && Number.isSafeInteger(depth) && depth >= 0 && depth <= 128 && rawFile !== undefined) {
+            const stack = stacks.get(rawFile) ?? [];
+            if (stack.length >= depth && !Array.isArray(rawData.ancestorNames) && !Array.isArray(rawData.ancestorTitles)) {
+                ancestors = stack.slice(0, depth);
+            }
+            if (type === "test:start" && rawName !== undefined) {
+                stack.length = depth;
+                stack.push(rawName);
+                stacks.set(rawFile, stack);
+            }
+        }
+        const data = ancestors === undefined ? rawData : { ...rawData, ancestorNames: ancestors };
+        if (terminal(value) || (type === "test:complete" &&
+            (value.completed === true || data.completed === true || value.terminal === true))) {
+            completed = true;
+            completionEvidence = [terminalEvidence(value, options.executionId)];
+            continue;
+        }
+        if (type === undefined) {
+            diagnostics.push("missing-event-type");
+            continue;
+        }
+        if (type === "test:summary" && data.success === false)
+            failedSummary = true;
+        if (type === "test:enqueue" || type === "test:dequeue" ||
+            type === "test:start" || type === "test:diagnostic" || type === "test:summary" ||
+            type === "test:coverage" || type === "test:stdout" || type === "test:stderr") {
+            if (type === "test:diagnostic" && (data.error !== undefined || data.failureClass !== undefined)) {
+                diagnostics.push(`node-diagnostic:${string(data.failureClass) ?? "infrastructure-error"}`);
+            }
+            continue;
+        }
+        const details = object(data.details);
+        const file = string(data.file ?? data.filePath);
+        const name = string(data.name);
+        const summary = lower(data.type ?? details?.type) === "suite" ||
+            (file !== undefined && name !== undefined && resolve(name) === resolve(file));
+        if (summary) {
+            const error = object(details?.error);
+            // A failed child already has its own result. Independent suite/file
+            // failures still poison the run; summaries never become check evidence.
+            if (error !== undefined && lower(error.failureType) !== "subtestsfailed") {
+                diagnostics.push(`node-summary:${nonAssertionFailure(data) ?? "infrastructure-error"}`);
+            }
+            continue;
+        }
+        if (type === "test:complete" && typeof data.nesting === "number")
+            continue;
+        if (type === "test:plan" || type === "plan") {
+            const count = data.count;
+            const nesting = typeof data.nesting === "number" ? data.nesting : 0;
+            if (nesting === 0 && typeof count === "number" && Number.isSafeInteger(count) && count >= 0) {
+                completed = true;
+                completionEvidence = [`node:test:plan:${count}`];
+            }
+            else if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0) {
+                diagnostics.push("malformed-plan");
+            }
+            continue;
+        }
+        const id = checkId(data);
+        if (id === undefined) {
+            diagnostics.push(`missing-check-id:${type}`);
+            continue;
+        }
+        const evidence = eventEvidence(type, data, id);
+        const attemptCount = attempts(data.attempts, hasRetry(data) ? 2 : 1);
+        if (type === "test:complete" || type === "test-complete") {
+            if (!seenCheckIds.has(id)) {
+                pendingComplete.set(id, { data, type, evidence, attempts: attemptCount });
+            }
+            continue;
+        }
+        if (hasRetry(data)) {
+            append(id, data, evidence, attemptCount);
+            continue;
+        }
+        if (type === "test:skip" || type === "test-skip" || type === "skip") {
+            append(id, { ...data, skip: true }, evidence, attemptCount);
+            continue;
+        }
+        if (type === "test:todo" || type === "test-todo" || type === "todo") {
+            append(id, { ...data, todo: true }, evidence, attemptCount);
+            continue;
+        }
+        if (type === "test:pass" || type === "test-pass" || type === "pass" ||
+            (type === "test:result" && lower(data.status) === "passed")) {
+            append(id, data, evidence, attemptCount, true);
+            continue;
+        }
+        if (type === "test:fail" || type === "test-fail" || type === "fail" ||
+            (type === "test:result" && lower(data.status) === "failed")) {
+            append(id, data, evidence, attemptCount, false);
+            continue;
+        }
+        diagnostics.push(`unsupported-event:${type}`);
+    }
+    for (const [id, pending] of pendingComplete.entries()) {
+        if (seenCheckIds.has(id))
+            continue;
+        const details = object(pending.data.details);
+        append(id, pending.data, pending.evidence, pending.attempts, typeof details?.passed === "boolean" ? details.passed : undefined);
+    }
+    for (let i = 0; i < results.length; i++) {
+        if (duplicateCheckIds.has(results[i].checkId)) {
+            results[i] = { ...results[i], status: "UNKNOWN", failureClass: "duplicate-check" };
+        }
+    }
+    if (failedSummary && results.every(result => result.status === "PASS")) {
+        diagnostics.push("unexplained-summary-failure");
+    }
+    return run(options, "node:test", results, completed, completionEvidence, diagnostics);
+}

package/dist/runtime/src/verify/adapters/pytest.js

@@ -0,0 +1,188 @@
+import { parseJsonDocument, parseJsonLines, stableCheckId } from "../acceptance-protocol.js";
+import { array, hasRetry, lower, number, object, result, run, string, terminalEvidence } from "./shared.js";
+function inputEvents(input) {
+    if (Array.isArray(input))
+        return { events: input, diagnostics: [] };
+    if (typeof input !== "string") {
+        const value = object(input);
+        if (value === undefined)
+            return { events: [], diagnostics: ["malformed-output"] };
+        return { events: [value], diagnostics: [] };
+    }
+    const document = parseJsonDocument(input);
+    if (Array.isArray(document))
+        return { events: document, diagnostics: [] };
+    if (object(document) !== undefined) {
+        const value = object(document);
+        return { events: [value], diagnostics: [] };
+    }
+    const lines = parseJsonLines(input);
+    return {
+        events: lines.values,
+        diagnostics: lines.invalidLines.map((line) => `invalid-json-line:${line}`)
+    };
+}
+function eventType(value) {
+    return lower(value.type ?? value.event ?? value.kind);
+}
+function nodeId(value) {
+    return string(value.nodeid ?? value.nodeId ?? value.testId ?? value.name ?? value.title);
+}
+function phaseValue(value) {
+    return object(value.report) ?? object(value.result) ?? value;
+}
+function phaseName(value) {
+    return lower(value.when ?? value.phase ?? value.stage) ?? "unknown";
+}
+function outcome(value) {
+    return lower(value.outcome ?? value.status ?? value.state);
+}
+function assertionFailure(value) {
+    if (value.assertion === true || value.isAssertion === true)
+        return true;
+    const type = lower(value.errorType ?? value.exceptionType ?? value.errorName);
+    return type === "assertionerror" || type === "assertion-error";
+}
+function addRecord(grouped, raw, diagnostics) {
+    const id = nodeId(raw);
+    if (id === undefined) {
+        diagnostics.push("missing-check-id");
+        return;
+    }
+    let stable;
+    try {
+        stable = stableCheckId([id]);
+    }
+    catch {
+        diagnostics.push("missing-check-id");
+        return;
+    }
+    const phase = phaseValue(raw) ?? raw;
+    const evidenceId = string(raw.id ?? raw.reportId ?? raw.nodeid ?? raw.nodeId) ?? stable;
+    const attemptCount = number(raw.attempts ?? phase.attempts);
+    const list = grouped.get(stable) ?? [];
+    list.push({
+        phase: phaseName(phase),
+        outcome: outcome(phase),
+        assertion: assertionFailure(phase),
+        xfail: phase.wasxfail === true ||
+            (typeof phase.wasxfail === "string" && phase.wasxfail.length > 0) ||
+            phase.xfail === true || outcome(phase) === "xfailed" || outcome(phase) === "xpassed",
+        retry: hasRetry(raw) || hasRetry(phase),
+        attempts: attemptCount !== undefined && attemptCount > 0 ? attemptCount : null,
+        evidence: `pytest:${stable}:${evidenceId}`,
+        infrastructure: (phase.error !== undefined && phase.error !== null) ||
+            (phase.crash !== undefined && phase.crash !== null && phase.crash !== false)
+    });
+    grouped.set(stable, list);
+}
+function appendReportTests(report, grouped, diagnostics) {
+    const tests = array(report.tests) ?? [];
+    for (const raw of tests) {
+        const test = object(raw);
+        if (test === undefined) {
+            diagnostics.push("malformed-test");
+            continue;
+        }
+        const call = object(test.call);
+        const setup = object(test.setup);
+        const teardown = object(test.teardown);
+        if (setup !== undefined)
+            addRecord(grouped, { ...test, ...setup, phase: "setup" }, diagnostics);
+        if (call !== undefined)
+            addRecord(grouped, { ...test, ...call, phase: "call" }, diagnostics);
+        else
+            addRecord(grouped, test, diagnostics);
+        if (teardown !== undefined)
+            addRecord(grouped, { ...test, ...teardown, phase: "teardown" }, diagnostics);
+    }
+}
+/** Collect a structured pytest hook stream or pytest-json-report-like document. */
+export function collectPytestAcceptance(input, options) {
+    const parsed = inputEvents(input);
+    const grouped = new Map();
+    const diagnostics = [...parsed.diagnostics];
+    let completed = false;
+    let completionEvidence = [];
+    for (const raw of parsed.events) {
+        const value = object(raw);
+        if (value === undefined) {
+            diagnostics.push("malformed-event");
+            continue;
+        }
+        if (Array.isArray(value.tests)) {
+            appendReportTests(value, grouped, diagnostics);
+            if (value.completed !== false && value.interrupted !== true) {
+                completed = true;
+                completionEvidence = ["pytest:report:complete"];
+            }
+            continue;
+        }
+        const type = eventType(value);
+        if (["session-finished", "session-finish", "complete", "completed", "finished", "run-complete"].includes(type ?? "") &&
+            value.completed !== false && value.interrupted !== true) {
+            completed = true;
+            completionEvidence = [terminalEvidence(value, options.executionId)];
+            continue;
+        }
+        if (type === "session-error" || type === "internal-error" || type === "collection-error") {
+            diagnostics.push(`pytest:${type}`);
+            continue;
+        }
+        if (type === "test-report" || type === "runtest" || type === "test") {
+            addRecord(grouped, value, diagnostics);
+            continue;
+        }
+        diagnostics.push(`unsupported-event:${type ?? "unknown"}`);
+    }
+    const results = [];
+    for (const [id, records] of grouped.entries()) {
+        const refs = records.map((record) => record.evidence);
+        const attemptsCount = records.reduce((max, record) => {
+            if (max === null || record.attempts === null)
+                return null;
+            return Math.max(max, record.attempts);
+        }, 1);
+        if (records.some((record) => record.retry || (record.attempts !== null && record.attempts > 1))) {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "retry", attemptsCount === null ? null : Math.max(attemptsCount, 2)));
+            continue;
+        }
+        const setupOrTeardownFailure = records.some((record) => (record.phase === "setup" || record.phase === "teardown") &&
+            record.outcome !== "passed" && record.outcome !== "pass");
+        if (setupOrTeardownFailure || records.some((record) => record.infrastructure)) {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "fixture-error", attemptsCount));
+            continue;
+        }
+        const phases = records.map(record => record.phase);
+        if (new Set(phases).size !== phases.length) {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "duplicate-check", attemptsCount));
+            continue;
+        }
+        const call = records.find((record) => record.phase === "call");
+        if (phases.join(",") !== "setup,call,teardown" || call === undefined) {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "incomplete-output", attemptsCount));
+            continue;
+        }
+        if (call.xfail) {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "xfail", attemptsCount));
+        }
+        else if (call.outcome === "passed" || call.outcome === "pass") {
+            results.push(result(options, "pytest", id, "PASS", refs, "none", attemptsCount));
+        }
+        else if (call.outcome === "failed" || call.outcome === "fail") {
+            results.push(call.assertion
+                ? result(options, "pytest", id, "FAIL", refs, "assertion-failed", attemptsCount)
+                : result(options, "pytest", id, "UNKNOWN", refs, "infrastructure-error", attemptsCount));
+        }
+        else if (call.outcome === "skipped" || call.outcome === "skip") {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "skipped", attemptsCount));
+        }
+        else if (call.outcome === "xfailed" || call.outcome === "xpassed") {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "xfail", attemptsCount));
+        }
+        else {
+            results.push(result(options, "pytest", id, "UNKNOWN", refs, "incomplete-output", attemptsCount));
+        }
+    }
+    return run(options, "pytest", results, completed, completionEvidence, diagnostics);
+}