@kylecheng3146/agent-ops 0.5.3 → 0.6.0

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

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

@@ -0,0 +1,84 @@
+import { parseJsonDocument, parseJsonLines, stableCheckId } from "../acceptance-protocol.js";
+import { attempts, lower, object, result, run, string, terminal, terminalEvidence } from "./shared.js";
+function inputEvents(input) {
+    if (Array.isArray(input))
+        return { events: input, diagnostics: [] };
+    if (typeof input !== "string") {
+        const value = object(input);
+        return value === undefined
+            ? { events: [], diagnostics: ["malformed-output"] }
+            : { events: [value], diagnostics: [] };
+    }
+    const document = parseJsonDocument(input);
+    if (Array.isArray(document))
+        return { events: document, diagnostics: [] };
+    if (object(document) !== undefined)
+        return { events: [document], diagnostics: [] };
+    const lines = parseJsonLines(input);
+    return {
+        events: lines.values,
+        diagnostics: lines.invalidLines.map((line) => `invalid-json-line:${line}`)
+    };
+}
+function status(value) {
+    const normalized = lower(value);
+    if (normalized === "pass" || normalized === "passed" || normalized === "ok")
+        return "PASS";
+    if (normalized === "fail" || normalized === "failed")
+        return "FAIL";
+    return "UNKNOWN";
+}
+/**
+ * Collect the stdlib harness' JSON-lines output. Native libtest text without
+ * this explicit protocol is intentionally unsupported instead of guessed.
+ */
+export function collectRustAcceptance(input, options) {
+    const parsed = inputEvents(input);
+    const results = [];
+    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;
+        }
+        const type = lower(value.type ?? value.event ?? value.kind);
+        if (terminal(value) || type === "completed" || type === "complete") {
+            completed = true;
+            completionEvidence = [terminalEvidence(value, options.executionId)];
+            continue;
+        }
+        if (type !== "check" && type !== "assertion" && type !== "result") {
+            diagnostics.push(`unsupported-event:${type ?? "unknown"}`);
+            continue;
+        }
+        const rawId = string(value.checkId ?? value.testId ?? value.name);
+        if (rawId === undefined) {
+            diagnostics.push("missing-check-id");
+            continue;
+        }
+        let checkId;
+        try {
+            checkId = stableCheckId([rawId]);
+        }
+        catch {
+            diagnostics.push("missing-check-id");
+            continue;
+        }
+        const checkStatus = status(value.status ?? value.outcome ?? value.state);
+        const failureClass = lower(value.failureClass ?? value.failureKind) ??
+            (checkStatus === "PASS" ? "none" : checkStatus === "FAIL" ? "infrastructure-error" : "unsupported-output");
+        const evidence = Array.isArray(value.evidence)
+            ? value.evidence.filter((item) => typeof item === "string")
+            : [`rust:${checkId}`];
+        try {
+            results.push(result(options, "rust-harness", checkId, checkStatus, evidence, failureClass, attempts(value.attempts, null)));
+        }
+        catch {
+            diagnostics.push(`malformed-result:${checkId}`);
+        }
+    }
+    return run(options, "rust-harness", results, completed, completionEvidence, diagnostics);
+}

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

@@ -0,0 +1,82 @@
+import { ACCEPTANCE_FAILURE, makeAcceptanceCheck, makeAcceptanceRun } from "../acceptance-protocol.js";
+export function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function string(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export function number(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
+}
+export function array(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+export function attempts(value, fallback = 1) {
+    const parsed = number(value);
+    return parsed === undefined ? fallback : parsed;
+}
+export function result(options, framework, checkId, status, evidence, failureClass = status === "PASS" ? "none" : ACCEPTANCE_FAILURE.infrastructure, attemptCount = 1) {
+    return makeAcceptanceCheck({
+        executionId: options.executionId,
+        framework,
+        frameworkVersion: options.frameworkVersion,
+        checkId,
+        phase: options.phase,
+        status,
+        failureClass,
+        attempts: attemptCount,
+        evidence
+    });
+}
+export function unknownResult(options, framework, checkId, failureClass, evidence = ["adapter:unknown"], attemptCount = 1) {
+    return result(options, framework, checkId, "UNKNOWN", evidence, failureClass, attemptCount);
+}
+export function run(options, framework, results, completed, completionEvidence, diagnostics = []) {
+    return makeAcceptanceRun({
+        executionId: options.executionId,
+        framework,
+        frameworkVersion: options.frameworkVersion,
+        phase: options.phase,
+        results,
+        completed,
+        completionEvidence,
+        diagnostics
+    });
+}
+export function lower(value) {
+    const text = string(value);
+    return text?.toLowerCase();
+}
+export function hasRetry(value) {
+    if (value.retry === true || value.retried === true)
+        return true;
+    const retryCount = number(value.retryCount);
+    if (retryCount !== undefined && retryCount > 0)
+        return true;
+    const repeatCount = number(value.repeatCount);
+    if (repeatCount !== undefined && repeatCount > 0)
+        return true;
+    const rerun = number(value.rerun);
+    if (rerun !== undefined && rerun > 0)
+        return true;
+    const invocations = number(value.invocations);
+    if (invocations !== undefined && invocations > 1)
+        return true;
+    if (Array.isArray(value.retryReasons) && value.retryReasons.length > 0)
+        return true;
+    const attemptsValue = number(value.attempts);
+    return attemptsValue !== undefined && attemptsValue > 1;
+}
+export function terminal(value) {
+    if (value.completed === true || value.complete === true || value.terminal === true)
+        return true;
+    const type = lower(value.type ?? value.event);
+    return type === "complete" || type === "completed" || type === "finished" ||
+        type === "session-finished" || type === "run-complete";
+}
+export function terminalEvidence(value, fallback) {
+    const id = string(value.executionId) ?? string(value.id) ?? fallback;
+    return `terminal:${id}`;
+}