engineering-behavior-observatory 0.2.1

package/dist/src/lifecycle.js

@@ -0,0 +1,1889 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, fsyncSync, linkSync, openSync, readFileSync, renameSync, unlinkSync } from "node:fs";
+import { lstat, mkdir, open, readFile, rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export class InvalidLifecycleTransitionError extends Error {
+    constructor(from, to) {
+        super(`Invalid lifecycle transition from "${from}" to "${to}".`);
+        this.name = "InvalidLifecycleTransitionError";
+    }
+}
+const ALLOWED_TRANSITIONS = {
+    created: ["setup", "cleaning"],
+    setup: ["running", "cleaning"],
+    running: ["verifying", "cleaning"],
+    verifying: ["cleaning"],
+    cleaning: ["terminal"],
+    terminal: [],
+};
+const LIFECYCLE_PROGRESS = {
+    created: 0,
+    setup: 1,
+    running: 2,
+    verifying: 3,
+    cleaning: 4,
+    terminal: 5,
+};
+const MAX_TIMER_MS = 2_147_483_647;
+class TerminalPublicationCancelled extends Error {
+    constructor() {
+        super("Terminal publication was cancelled before installation.");
+        this.name = "TerminalPublicationCancelled";
+    }
+}
+export function createRunIdentity(input) {
+    const run = {
+        id: input.id ?? randomUUID(),
+        taskId: input.taskId,
+        modelId: input.modelId,
+        harnessId: input.harnessId,
+    };
+    assertIdentity(run.id, "Run ID");
+    assertIdentity(run.taskId, "Task ID");
+    assertIdentity(run.modelId, "Model ID");
+    assertIdentity(run.harnessId, "Harness ID");
+    return run;
+}
+export function createAttemptIdentity(runId, number = 1, id = randomUUID(), retryOf) {
+    assertIdentity(runId, "Run ID");
+    assertIdentity(id, "Attempt ID");
+    if (!Number.isSafeInteger(number) || number < 1)
+        throw new Error("Attempt number must be a positive safe integer.");
+    if (retryOf !== undefined) {
+        assertIdentity(retryOf, "Retry attempt ID");
+        if (retryOf === id)
+            throw new Error("An attempt cannot retry itself.");
+        if (number < 2)
+            throw new Error("A retry attempt must have number 2 or greater.");
+    }
+    else if (number > 1) {
+        throw new Error("Attempt numbers greater than 1 require retryOf.");
+    }
+    return { id, number, ...(retryOf === undefined ? {} : { retryOf }) };
+}
+export function retryAttempt(previous, id = randomUUID()) {
+    const identity = "attempt" in previous ? previous.attempt : previous;
+    if (!Number.isSafeInteger(identity.number) || identity.number < 1) {
+        throw new Error("Previous attempt number must be a positive safe integer.");
+    }
+    return createAttemptIdentity("retry", identity.number + 1, id, identity.id);
+}
+export class LifecycleController {
+    now;
+    transitions = [];
+    timestamps;
+    current = "created";
+    createdAt;
+    endedAt;
+    constructor(now = () => new Date().toISOString()) {
+        this.now = now;
+        const createdAt = this.now();
+        assertTimestampValue(createdAt, "Lifecycle created timestamp");
+        this.createdAt = createdAt;
+        this.timestamps = { created: this.createdAt };
+    }
+    get state() {
+        return this.current;
+    }
+    transition(to, at = this.now()) {
+        assertTimestampValue(at, "Lifecycle transition timestamp");
+        if (!ALLOWED_TRANSITIONS[this.current].includes(to)) {
+            throw new InvalidLifecycleTransitionError(this.current, to);
+        }
+        this.transitions.push({ from: this.current, to, at });
+        this.current = to;
+        this.timestamps[to] = at;
+        if (to === "terminal")
+            this.endedAt = at;
+        return this.snapshot();
+    }
+    snapshot() {
+        return {
+            state: this.current,
+            createdAt: this.createdAt,
+            startedAt: this.timestamps.setup ?? this.createdAt,
+            ...(this.endedAt === undefined ? {} : { endedAt: this.endedAt }),
+            timestamps: { ...this.timestamps },
+            transitions: this.transitions.map((transition) => ({ ...transition })),
+        };
+    }
+}
+export async function executeRunAttempt(options) {
+    validateOptions(options);
+    const workspaceCoordinator = options.workspace;
+    const workspaceSetup = workspaceCoordinator.setup;
+    const workspaceCleanup = workspaceCoordinator.cleanup;
+    const harnessExecutor = options.harness;
+    const verifierExecutor = options.verifier;
+    const assessmentMode = options.assessmentMode ?? "verified";
+    const evidenceSink = options.evidence;
+    const evidenceFlush = evidenceSink?.flush;
+    const signal = options.signal;
+    const recordPath = options.recordPath;
+    const maxWallClockMs = options.maxWallClockMs;
+    const harnessBudgetMs = options.harnessBudgetMs;
+    const shutdownGraceMs = options.shutdownGraceMs ?? 250;
+    const now = options.now ?? (() => new Date().toISOString());
+    const attempt = options.attempt ?? createAttemptIdentity(options.run.id);
+    const runSnapshot = structuredClone(options.run);
+    const attemptSnapshot = structuredClone(attempt);
+    const lifecycle = new LifecycleController(now);
+    const controller = new AbortController();
+    const executionStartedAt = Date.now();
+    const record = {
+        schemaVersion: "ebo.attempt/v1",
+        assessmentMode,
+        run: structuredClone(runSnapshot),
+        attempt: structuredClone(attemptSnapshot),
+        lifecycle: lifecycle.snapshot(),
+        partial: true,
+    };
+    if (evidenceFlush === undefined) {
+        record.capture = { status: "incomplete", error: "Evidence flush boundary is unavailable." };
+    }
+    let persistenceError;
+    let initialCheckpointError;
+    let reservationPath;
+    let allowTerminalReplacement = false;
+    if (recordPath !== undefined) {
+        await assertAttemptRecordPathAvailable(recordPath, runSnapshot, attemptSnapshot);
+        reservationPath = await reserveAttemptRecordPath(recordPath);
+    }
+    const persist = async () => {
+        record.lifecycle = lifecycle.snapshot();
+        if (recordPath === undefined)
+            return;
+        try {
+            record.persistence = { status: "complete" };
+            const publicationGate = lifecycle.state === "terminal"
+                && classification !== undefined
+                && classificationUnderlyingKind(classification) === "completed"
+                ? () => {
+                    markCoordinatorBudgetIfExpired();
+                    if (controller.signal.aborted || budgetExpired !== undefined)
+                        throw new TerminalPublicationCancelled();
+                }
+                : undefined;
+            await writeAttemptRecordInternal(recordPath, record, allowTerminalReplacement, publicationGate);
+        }
+        catch (error) {
+            if (error instanceof TerminalPublicationCancelled) {
+                record.persistence = { status: "complete" };
+                return;
+            }
+            persistenceError ??= errorMessage(error);
+            record.persistence = { status: "incomplete", error: persistenceError };
+        }
+    };
+    const flush = async () => {
+        try {
+            if (evidenceFlush !== undefined) {
+                const evidenceFlushPromise = Promise.resolve(evidenceFlush.call(evidenceSink));
+                const outcome = await Promise.race([
+                    evidenceFlushPromise.then(() => "complete"),
+                    abortPromise.then(() => "aborted"),
+                ]);
+                if (outcome === "aborted") {
+                    const settledFlush = await settleWithTimeout(evidenceFlushPromise, shutdownGraceMs);
+                    if (settledFlush.status === "failed")
+                        throw settledFlush.error;
+                    if (settledFlush.status === "timed-out")
+                        throw new Error("Evidence flush interrupted.");
+                }
+            }
+        }
+        catch (error) {
+            if (record.capture?.status !== "incomplete") {
+                record.capture = { status: "incomplete", error: errorMessage(error) };
+            }
+        }
+        if (record.capture?.status !== "incomplete" && record.harness?.captureError !== undefined) {
+            record.capture = { status: "incomplete", error: record.harness.captureError };
+        }
+        await persist();
+    };
+    let abortCause;
+    const externalAbort = () => {
+        abortCause ??= "interrupted";
+        controller.abort("interrupted");
+    };
+    if (signal?.aborted)
+        externalAbort();
+    else
+        signal?.addEventListener("abort", externalAbort, { once: true });
+    let budgetTimer;
+    let budgetExpired;
+    let harnessDeadlineAt;
+    let harnessResult;
+    let workspace;
+    let classification;
+    let cleanupStatus;
+    let harnessShutdown;
+    let workspaceShutdown;
+    let workspaceTerminationConfirmed = true;
+    let verifierShutdown;
+    let setupStarted = false;
+    const abortPromise = new Promise((resolveAbort) => {
+        if (controller.signal.aborted)
+            resolveAbort("aborted");
+        else
+            controller.signal.addEventListener("abort", () => resolveAbort("aborted"), { once: true });
+    });
+    const noteBudgetStop = (requested) => {
+        if (abortCause === "interrupted")
+            return;
+        const nowMs = Date.now();
+        const coordinatorDeadlineAt = maxWallClockMs === undefined ? undefined : executionStartedAt + maxWallClockMs;
+        const source = coordinatorDeadlineAt !== undefined && harnessDeadlineAt !== undefined
+            && nowMs >= coordinatorDeadlineAt && nowMs >= harnessDeadlineAt
+            ? coordinatorDeadlineAt <= harnessDeadlineAt ? "coordinator" : "harness"
+            : requested;
+        abortCause ??= "budget";
+        budgetExpired = source;
+        controller.abort("budget");
+    };
+    if (maxWallClockMs !== undefined) {
+        budgetTimer = setTimeout(() => noteBudgetStop("coordinator"), maxWallClockMs);
+    }
+    const markCoordinatorBudgetIfExpired = () => {
+        if (maxWallClockMs !== undefined && Date.now() - executionStartedAt >= maxWallClockMs) {
+            noteBudgetStop("coordinator");
+        }
+    };
+    try {
+        await flush();
+        if (persistenceError !== undefined) {
+            initialCheckpointError = persistenceError;
+            throw new Error(`Initial attempt checkpoint could not be persisted: ${persistenceError}`);
+        }
+        lifecycle.transition("setup");
+        await persist();
+        if (persistenceError !== undefined) {
+            initialCheckpointError ??= persistenceError;
+            throw new Error(`Initial attempt checkpoint could not be persisted: ${persistenceError}`);
+        }
+        try {
+            markCoordinatorBudgetIfExpired();
+            if (controller.signal.aborted) {
+                classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+            }
+            else {
+                setupStarted = true;
+                const setupPromise = Promise.resolve(workspaceSetup.call(workspaceCoordinator, {
+                    run: structuredClone(runSnapshot),
+                    attempt: structuredClone(attemptSnapshot),
+                    signal: controller.signal,
+                    registerShutdown: (shutdown) => { workspaceShutdown = shutdown; },
+                }));
+                const setupOutcome = await Promise.race([
+                    setupPromise.then((value) => ({ kind: "result", value })),
+                    abortPromise.then((value) => ({ kind: value })),
+                ]);
+                if (setupOutcome.kind === "aborted" || controller.signal.aborted) {
+                    const settledSetup = await settleWithTimeout(setupPromise, shutdownGraceMs);
+                    if (settledSetup.status === "completed") {
+                        workspace = snapshotWorkspace(settledSetup.value);
+                        record.workspace = snapshotWorkspace(workspace);
+                        workspaceTerminationConfirmed = workspace.shutdownResult === undefined || workspace.shutdownResult.status === "completed";
+                        if (workspaceShutdown !== undefined) {
+                            workspaceTerminationConfirmed = false;
+                            const shutdownResult = await shutdownWorkspace(workspaceShutdown, shutdownGraceMs);
+                            if (shutdownResult !== undefined) {
+                                workspace = { ...workspace, shutdownResult };
+                                record.workspace = snapshotWorkspace(workspace);
+                                workspaceTerminationConfirmed = shutdownResult.status === "completed";
+                            }
+                        }
+                    }
+                    else if (settledSetup.status === "failed") {
+                        record.workspace = { status: "failed", error: errorMessage(settledSetup.error) };
+                        if (workspaceShutdown !== undefined) {
+                            workspaceTerminationConfirmed = false;
+                            const shutdownResult = await shutdownWorkspace(workspaceShutdown, shutdownGraceMs);
+                            if (shutdownResult !== undefined) {
+                                record.workspace.shutdownResult = shutdownResult;
+                                workspaceTerminationConfirmed = shutdownResult.status === "completed";
+                            }
+                        }
+                    }
+                    else {
+                        record.workspace = { status: "failed", error: settledSetup.error };
+                        workspaceTerminationConfirmed = false;
+                        const shutdownResult = await shutdownWorkspace(workspaceShutdown, shutdownGraceMs);
+                        if (shutdownResult !== undefined) {
+                            record.workspace.shutdownResult = shutdownResult;
+                            workspaceTerminationConfirmed = shutdownResult.status === "completed";
+                        }
+                    }
+                    classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+                }
+                else {
+                    workspace = snapshotWorkspace(setupOutcome.value);
+                    record.workspace = snapshotWorkspace(workspace);
+                    workspaceTerminationConfirmed = workspace.shutdownResult === undefined || workspace.shutdownResult.status === "completed";
+                    if (!workspaceTerminationConfirmed) {
+                        classification = infrastructureClassification("Workspace shutdown did not complete.", "workspace", workspace);
+                    }
+                    if (workspace.status === "failed") {
+                        classification ??= infrastructureClassification("Workspace setup failed.", "workspace", workspace);
+                        if (workspaceShutdown !== undefined) {
+                            workspaceTerminationConfirmed = false;
+                            const shutdownResult = await shutdownWorkspace(workspaceShutdown, shutdownGraceMs);
+                            if (shutdownResult !== undefined) {
+                                workspace = { ...workspace, shutdownResult };
+                                record.workspace = snapshotWorkspace(workspace);
+                                workspaceTerminationConfirmed = shutdownResult.status === "completed";
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const setupError = errorMessage(error);
+            markCoordinatorBudgetIfExpired();
+            record.workspace = { status: "failed", error: setupError };
+            if (workspaceShutdown !== undefined) {
+                workspaceTerminationConfirmed = false;
+                const shutdownResult = await shutdownWorkspace(workspaceShutdown, shutdownGraceMs);
+                if (shutdownResult !== undefined)
+                    record.workspace = { ...record.workspace, shutdownResult };
+                workspaceTerminationConfirmed = shutdownResult?.status === "completed";
+            }
+            classification = controller.signal.aborted
+                ? abortClassification(abortCause, budgetExpired, setupError, workspace)
+                : infrastructureClassification(setupError, "workspace", workspace);
+        }
+        markCoordinatorBudgetIfExpired();
+        if (classification === undefined && controller.signal.aborted) {
+            classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+        }
+        await flush();
+        markCoordinatorBudgetIfExpired();
+        if (classification === undefined && controller.signal.aborted) {
+            classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+        }
+        if (classification === undefined) {
+            lifecycle.transition("running");
+            await persist();
+            markCoordinatorBudgetIfExpired();
+            if (controller.signal.aborted)
+                classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+        }
+        if (classification === undefined) {
+            const timers = [];
+            const installBudget = (milliseconds) => {
+                if (milliseconds === undefined)
+                    return;
+                const timer = setTimeout(() => noteBudgetStop("harness"), milliseconds);
+                timers.push(timer);
+            };
+            const harnessStartedAt = Date.now();
+            harnessDeadlineAt = harnessBudgetMs === undefined ? undefined : harnessStartedAt + harnessBudgetMs;
+            installBudget(harnessBudgetMs);
+            let harnessPromise;
+            let harnessError;
+            try {
+                harnessPromise = Promise.resolve(harnessExecutor.call(options, {
+                    run: structuredClone(runSnapshot),
+                    attempt: structuredClone(attemptSnapshot),
+                    signal: controller.signal,
+                    ...(harnessBudgetMs === undefined ? {} : { budgetMs: harnessBudgetMs }),
+                    ...(workspace === undefined ? {} : { workspace: snapshotWorkspace(workspace) }),
+                    registerShutdown: (shutdown) => { harnessShutdown = shutdown; },
+                }));
+            }
+            catch (error) {
+                harnessPromise = Promise.reject(error);
+            }
+            if (harnessBudgetMs !== undefined && Date.now() - harnessStartedAt >= harnessBudgetMs) {
+                noteBudgetStop("harness");
+            }
+            markCoordinatorBudgetIfExpired();
+            let outcome;
+            try {
+                outcome = await Promise.race([
+                    harnessPromise.then((value) => ({ kind: "result", value })),
+                    abortPromise.then((value) => ({ kind: value })),
+                ]);
+            }
+            catch (error) {
+                harnessError = errorMessage(error);
+                classification = controller.signal.aborted
+                    ? abortClassification(abortCause, budgetExpired, harnessError, workspace)
+                    : infrastructureClassification(harnessError, "harness", workspace);
+            }
+            finally {
+                for (const timer of timers)
+                    clearTimeout(timer);
+            }
+            const postBudgetHarness = budgetExpired === "harness"
+                ? {
+                    status: "stopped",
+                    stopReason: "budget",
+                    reason: "Harness result arrived after its budget deadline.",
+                    ...(harnessError === undefined ? {} : { error: harnessError }),
+                }
+                : undefined;
+            const rejectedHarness = postBudgetHarness ?? {
+                status: "failed",
+                ...(harnessError === undefined && classification?.reason === undefined ? {} : { error: harnessError ?? classification?.reason }),
+            };
+            if (outcome === undefined)
+                record.harness = rejectedHarness;
+            if (outcome === undefined && harnessShutdown !== undefined) {
+                const shutdownResult = await shutdownHarness(undefined, harnessShutdown, shutdownGraceMs);
+                record.harness = {
+                    ...rejectedHarness,
+                    ...(shutdownResult === undefined ? {} : { shutdownResult }),
+                };
+                record.harnessTerminationConfirmed = shutdownResult?.status === "completed";
+            }
+            else if (outcome === undefined) {
+                record.harnessTerminationConfirmed = true;
+            }
+            if (outcome !== undefined && (outcome.kind === "aborted" || controller.signal.aborted)) {
+                let harnessTerminationConfirmed = false;
+                if (outcome.kind === "result") {
+                    harnessResult = normalizeHarnessBudgetResult(outcome.value, budgetExpired);
+                    record.harness = durableHarnessResult(harnessResult);
+                    harnessTerminationConfirmed = harnessResult.shutdownResult === undefined || harnessResult.shutdownResult.status === "completed";
+                }
+                const settledHarness = await settleWithTimeout(harnessPromise, shutdownGraceMs);
+                if (settledHarness.status === "completed" && harnessResult === undefined) {
+                    harnessResult = normalizeHarnessBudgetResult(settledHarness.value, budgetExpired);
+                    record.harness = durableHarnessResult(harnessResult);
+                    harnessTerminationConfirmed = harnessResult.shutdownResult === undefined || harnessResult.shutdownResult.status === "completed";
+                }
+                else if (settledHarness.status === "failed" && harnessResult === undefined) {
+                    record.harness = { status: "interrupted", error: errorMessage(settledHarness.error) };
+                    harnessTerminationConfirmed = true;
+                }
+                else if (settledHarness.status === "timed-out" && harnessResult === undefined) {
+                    record.harness = { status: "interrupted", error: settledHarness.error };
+                }
+                classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+                const shutdownResult = await shutdownHarness(harnessResult, harnessShutdown, shutdownGraceMs);
+                if (shutdownResult !== undefined) {
+                    if (harnessResult !== undefined) {
+                        harnessResult = { ...harnessResult, shutdownResult };
+                        record.harness = durableHarnessResult(harnessResult);
+                    }
+                    else {
+                        record.harness = { status: "interrupted", shutdownResult };
+                    }
+                    harnessTerminationConfirmed = shutdownResult.status === "completed";
+                }
+                if (!harnessTerminationConfirmed)
+                    record.harness = {
+                        ...(record.harness ?? { status: "interrupted" }),
+                        error: record.harness?.error ?? "Harness execution did not terminate before cleanup.",
+                    };
+                record.harnessTerminationConfirmed = harnessTerminationConfirmed;
+            }
+            else if (outcome?.kind === "result") {
+                harnessResult = normalizeHarnessShutdownFailure(normalizeHarnessBudgetResult(outcome.value, budgetExpired));
+                record.harness = durableHarnessResult(harnessResult);
+                classification = classifyHarness(harnessResult, workspace);
+                if (classification !== undefined && harnessResult.status !== "completed") {
+                    let harnessTerminationConfirmed = harnessResult.shutdownResult === undefined || harnessResult.shutdownResult.status === "completed";
+                    if (harnessShutdown !== undefined || harnessResult.shutdown !== undefined) {
+                        harnessTerminationConfirmed = false;
+                        const shutdownResult = await shutdownHarness(harnessResult, harnessShutdown, shutdownGraceMs);
+                        if (shutdownResult !== undefined) {
+                            harnessResult = { ...harnessResult, shutdownResult };
+                            record.harness = durableHarnessResult(harnessResult);
+                            harnessTerminationConfirmed = shutdownResult.status === "completed";
+                        }
+                    }
+                    record.harnessTerminationConfirmed = harnessTerminationConfirmed;
+                }
+                if (classification === undefined && harnessResult.status === "completed") {
+                    if (assessmentMode === "observational") {
+                        markCoordinatorBudgetIfExpired();
+                        classification = controller.signal.aborted
+                            ? abortClassification(abortCause, budgetExpired, undefined, workspace)
+                            : completedClassification(workspace);
+                    }
+                    else {
+                        lifecycle.transition("verifying");
+                        await persist();
+                        markCoordinatorBudgetIfExpired();
+                        if (controller.signal.aborted) {
+                            classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+                        }
+                        else if (verifierExecutor === undefined) {
+                            record.verifier = { status: "not-run" };
+                            classification = infrastructureClassification("Verifier did not run.", "verifier", workspace);
+                        }
+                        else {
+                            try {
+                                const verifierPromise = Promise.resolve(verifierExecutor.call(options, {
+                                    run: structuredClone(runSnapshot),
+                                    attempt: structuredClone(attemptSnapshot),
+                                    signal: controller.signal,
+                                    ...(workspace === undefined ? {} : { workspace: snapshotWorkspace(workspace) }),
+                                    registerShutdown: (shutdown) => { verifierShutdown = shutdown; },
+                                }));
+                                const verifierOutcome = await Promise.race([
+                                    verifierPromise.then((value) => ({ kind: "result", value })),
+                                    abortPromise.then((value) => ({ kind: value })),
+                                ]);
+                                if (verifierOutcome.kind === "aborted" || controller.signal.aborted) {
+                                    let verifierTerminationConfirmed = false;
+                                    if (verifierOutcome.kind === "result") {
+                                        record.verifier = snapshotVerifier(verifierOutcome.value);
+                                        verifierTerminationConfirmed = record.verifier.shutdownResult === undefined || record.verifier.shutdownResult.status === "completed";
+                                    }
+                                    const settledVerifier = await settleWithTimeout(verifierPromise, shutdownGraceMs);
+                                    if (settledVerifier.status === "completed" && record.verifier === undefined) {
+                                        record.verifier = snapshotVerifier(settledVerifier.value);
+                                        verifierTerminationConfirmed = record.verifier.shutdownResult === undefined || record.verifier.shutdownResult.status === "completed";
+                                    }
+                                    if (settledVerifier.status === "failed" && record.verifier === undefined) {
+                                        record.verifier = { status: "error", error: errorMessage(settledVerifier.error) };
+                                        verifierTerminationConfirmed = true;
+                                    }
+                                    if (settledVerifier.status === "timed-out" && record.verifier === undefined) {
+                                        record.verifier = { status: "error", error: settledVerifier.error };
+                                    }
+                                    const shutdownResult = await shutdownVerifier(verifierShutdown, shutdownGraceMs);
+                                    if (shutdownResult !== undefined) {
+                                        record.verifier = {
+                                            ...(record.verifier ?? { status: "error" }),
+                                            shutdownResult,
+                                        };
+                                        verifierTerminationConfirmed = shutdownResult.status === "completed";
+                                    }
+                                    record.verifierTerminationConfirmed = verifierTerminationConfirmed;
+                                    classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+                                }
+                                else {
+                                    let verifier = normalizeVerifierShutdownFailure(snapshotVerifier(verifierOutcome.value));
+                                    record.verifier = verifier;
+                                    if (verifier.status !== "passed") {
+                                        let verifierTerminationConfirmed = verifier.shutdownResult === undefined || verifier.shutdownResult.status === "completed";
+                                        if (verifierShutdown !== undefined) {
+                                            verifierTerminationConfirmed = false;
+                                            const shutdownResult = await shutdownVerifier(verifierShutdown, shutdownGraceMs);
+                                            if (shutdownResult !== undefined) {
+                                                verifier = normalizeVerifierShutdownFailure({ ...verifier, shutdownResult });
+                                                record.verifier = verifier;
+                                                verifierTerminationConfirmed = shutdownResult.status === "completed";
+                                            }
+                                        }
+                                        record.verifierTerminationConfirmed = verifierTerminationConfirmed;
+                                    }
+                                    markCoordinatorBudgetIfExpired();
+                                    classification = controller.signal.aborted
+                                        ? abortClassification(abortCause, budgetExpired, undefined, workspace)
+                                        : classifyVerifier(verifier, workspace);
+                                }
+                            }
+                            catch (error) {
+                                const verifierError = errorMessage(error);
+                                record.verifier = { status: "error", error: verifierError };
+                                record.verifierTerminationConfirmed = true;
+                                if (verifierShutdown !== undefined) {
+                                    const shutdownResult = await shutdownVerifier(verifierShutdown, shutdownGraceMs);
+                                    if (shutdownResult !== undefined) {
+                                        record.verifier.shutdownResult = shutdownResult;
+                                        record.verifierTerminationConfirmed = shutdownResult.status === "completed";
+                                    }
+                                }
+                                markCoordinatorBudgetIfExpired();
+                                classification = controller.signal.aborted
+                                    ? abortClassification(abortCause, budgetExpired, verifierError, workspace)
+                                    : verifierErrorClassification(verifierError, workspace);
+                            }
+                        }
+                    }
+                }
+            }
+            await flush();
+        }
+    }
+    catch (error) {
+        classification ??= infrastructureClassification(errorMessage(error), "runner", workspace);
+    }
+    finally {
+        if (lifecycle.state !== "cleaning" && lifecycle.state !== "terminal") {
+            try {
+                lifecycle.transition("cleaning");
+            }
+            catch (error) {
+                classification ??= infrastructureClassification(errorMessage(error), "runner", workspace);
+                const snapshot = lifecycle.snapshot();
+                lifecycle.transition("cleaning", snapshot.timestamps[snapshot.state] ?? snapshot.createdAt);
+            }
+            await persist();
+        }
+        if (!setupStarted && workspace === undefined) {
+            cleanupStatus = { status: "completed" };
+        }
+        else if (record.harnessTerminationConfirmed === false) {
+            cleanupStatus = { status: "timed-out", error: "Harness execution did not terminate before cleanup." };
+        }
+        else if (record.verifierTerminationConfirmed === false) {
+            cleanupStatus = { status: "timed-out", error: "Verifier execution did not terminate before cleanup." };
+        }
+        else if (!workspaceTerminationConfirmed) {
+            cleanupStatus = { status: "timed-out", error: "Workspace setup did not terminate before cleanup." };
+        }
+        else
+            try {
+                const cleanupPromise = Promise.resolve(workspaceCleanup?.call(workspaceCoordinator, {
+                    run: structuredClone(runSnapshot),
+                    attempt: structuredClone(attemptSnapshot),
+                    signal: controller.signal,
+                    outcome: structuredClone(classification?.terminal ?? infrastructureClassification("Run did not produce a terminal outcome.", "runner").terminal),
+                    ...(workspace === undefined ? {} : { workspace: snapshotWorkspace(workspace) }),
+                }));
+                const cleanupOutcome = await Promise.race([
+                    cleanupPromise.then(() => "completed"),
+                    abortPromise.then(() => "aborted"),
+                ]);
+                if (cleanupOutcome === "aborted") {
+                    const settledCleanup = await settleWithTimeout(cleanupPromise, shutdownGraceMs);
+                    if (settledCleanup.status === "timed-out") {
+                        cleanupStatus = { status: "timed-out", error: settledCleanup.error };
+                    }
+                    else if (settledCleanup.status === "failed") {
+                        cleanupStatus = { status: "failed", error: errorMessage(settledCleanup.error) };
+                    }
+                    else {
+                        cleanupStatus = { status: "completed" };
+                    }
+                }
+                else {
+                    cleanupStatus = { status: "completed" };
+                }
+            }
+            catch (error) {
+                cleanupStatus = { status: "failed", error: errorMessage(error) };
+                markCoordinatorBudgetIfExpired();
+                if (abortCause === "budget" && classificationUnderlyingKind(classification ?? completedClassification(workspace)) === "completed") {
+                    classification = abortClassification(abortCause, budgetExpired, errorMessage(error), workspace);
+                }
+                else if (classification === undefined || classificationUnderlyingKind(classification) === "completed") {
+                    classification = infrastructureClassification(errorMessage(error), "cleanup", workspace);
+                }
+            }
+        markCoordinatorBudgetIfExpired();
+        if (cleanupStatus?.status === "timed-out" && classificationUnderlyingKind(classification ?? infrastructureClassification("Run did not produce a terminal outcome.", "runner")) === "completed"
+            && abortCause === "budget") {
+            classification = abortClassification(abortCause, budgetExpired, cleanupStatus.error, workspace);
+        }
+        else if (cleanupStatus?.status === "timed-out" && classificationUnderlyingKind(classification ?? infrastructureClassification("Run did not produce a terminal outcome.", "runner")) === "completed") {
+            classification = infrastructureClassification(cleanupStatus.error ?? "Workspace cleanup timed out.", "cleanup", workspace);
+        }
+        record.cleanup = cleanupStatus;
+        await flush();
+        markCoordinatorBudgetIfExpired();
+        if (record.capture?.status !== "incomplete" && evidenceFlush !== undefined) {
+            record.capture = { status: "complete" };
+        }
+        if (budgetExpired !== undefined && classification?.kind === "completed") {
+            classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+        }
+        if (controller.signal.aborted && classification?.kind === "completed") {
+            classification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+        }
+        if (persistenceError !== undefined && classification !== undefined && classificationUnderlyingKind(classification) === "completed") {
+            classification = infrastructureClassification(persistenceError, "runner", workspace);
+        }
+        if (record.capture?.status === "incomplete" && classification !== undefined && classification.kind !== "capture-incomplete") {
+            classification = {
+                kind: "capture-incomplete",
+                terminal: classification.terminal,
+                reason: record.capture.error,
+                source: "capture",
+                underlying: classification.kind,
+                ...(classification.source === undefined ? {} : { underlyingSource: classification.source }),
+            };
+        }
+        markCoordinatorBudgetIfExpired();
+        try {
+            lifecycle.transition("terminal");
+        }
+        catch (error) {
+            const runnerFailure = infrastructureClassification(errorMessage(error), "runner", workspace);
+            classification = record.capture?.status === "incomplete"
+                ? {
+                    kind: "capture-incomplete",
+                    terminal: runnerFailure.terminal,
+                    ...(record.capture.error === undefined ? {} : { reason: record.capture.error }),
+                    source: "capture",
+                    underlying: runnerFailure.kind,
+                    ...(runnerFailure.source === undefined ? {} : { underlyingSource: runnerFailure.source }),
+                }
+                : runnerFailure;
+            const fallbackTimestamp = lifecycle.snapshot().timestamps.cleaning ?? lifecycle.snapshot().createdAt;
+            lifecycle.transition("terminal", fallbackTimestamp);
+        }
+        classification ??= infrastructureClassification("Run did not produce a terminal outcome.", "runner", workspace);
+        record.classification = classification;
+        record.terminal = classification.terminal;
+        record.partial = classificationUnderlyingKind(classification) !== "completed"
+            || record.capture?.status === "incomplete";
+        const persistenceBeforeTerminal = persistenceError;
+        await persist();
+        markCoordinatorBudgetIfExpired();
+        if (classificationUnderlyingKind(classification) === "completed"
+            && (budgetExpired !== undefined || abortCause === "interrupted")) {
+            const correctedClassification = abortClassification(abortCause, budgetExpired, undefined, workspace);
+            classification = record.capture?.status === "incomplete"
+                ? {
+                    kind: "capture-incomplete",
+                    terminal: correctedClassification.terminal,
+                    ...(record.capture.error === undefined ? {} : { reason: record.capture.error }),
+                    source: "capture",
+                    underlying: correctedClassification.kind,
+                    ...(correctedClassification.source === undefined ? {} : { underlyingSource: correctedClassification.source }),
+                }
+                : correctedClassification;
+            record.classification = classification;
+            record.terminal = classification.terminal;
+            record.partial = true;
+            allowTerminalReplacement = true;
+            await persist();
+            allowTerminalReplacement = false;
+        }
+        if (persistenceError !== undefined && persistenceBeforeTerminal === undefined
+            && classificationUnderlyingKind(classification) === "completed") {
+            const failedPersistence = infrastructureClassification(persistenceError, "runner", workspace);
+            classification = record.capture?.status === "incomplete"
+                ? {
+                    ...failedPersistence,
+                    kind: "capture-incomplete",
+                    source: "capture",
+                    underlying: failedPersistence.kind,
+                    ...(failedPersistence.source === undefined ? {} : { underlyingSource: failedPersistence.source }),
+                }
+                : failedPersistence;
+            record.classification = classification;
+            record.terminal = classification.terminal;
+            record.partial = true;
+            // The second write may still fail, but the returned record retains the
+            // persistence failure rather than reporting an unverified completion.
+            allowTerminalReplacement = true;
+            await persist();
+            allowTerminalReplacement = false;
+        }
+        if (budgetTimer !== undefined)
+            clearTimeout(budgetTimer);
+        signal?.removeEventListener("abort", externalAbort);
+        if (reservationPath !== undefined)
+            await rm(reservationPath, { force: true });
+        if (initialCheckpointError !== undefined) {
+            throw new Error(`Initial attempt checkpoint could not be persisted: ${initialCheckpointError}`);
+        }
+    }
+    return {
+        run: structuredClone(record.run),
+        attempt: structuredClone(record.attempt),
+        record: structuredClone(record),
+        terminal: structuredClone(record.terminal),
+        classification: structuredClone(record.classification),
+    };
+}
+export async function writeAttemptRecord(path, record) {
+    if (path.trim() === "")
+        throw new Error("Attempt record path is required.");
+    assertRecord(record);
+    assertJsonValue(record, "attempt record", new Set());
+    const destination = resolve(path);
+    await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
+    await withRecordReservationLock(destination, () => writeAttemptRecordInternal(path, record));
+}
+async function writeAttemptRecordInternal(path, record, allowTerminalReplacement = false, publicationGate) {
+    assertRecord(record);
+    const destination = resolve(path);
+    await withRecordPublicationLock(destination, async () => {
+        const temporary = `${destination}.${randomUUID()}.tmp`;
+        const bytes = Buffer.from(`${JSON.stringify(record)}\n`, "utf8");
+        const handle = await open(temporary, "wx", 0o600);
+        try {
+            await writeFileHandleFully(handle, bytes, "Attempt record");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        try {
+            publicationGate?.();
+            try {
+                linkSync(temporary, destination);
+                unlinkSync(temporary);
+                syncDirectory(dirname(destination));
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const existing = readAttemptRecordSync(destination);
+                if (existing.run.id !== record.run.id || existing.attempt.id !== record.attempt.id) {
+                    throw new Error(`Attempt record "${path}" already belongs to another attempt.`);
+                }
+                if (!allowTerminalReplacement && (existing.terminal !== undefined || existing.classification !== undefined)) {
+                    throw new Error(`Attempt record "${path}" is already terminal.`);
+                }
+                if (!allowTerminalReplacement)
+                    assertCheckpointDoesNotRegress(existing, record);
+                publicationGate?.();
+                renameSync(temporary, destination);
+                syncDirectory(dirname(destination));
+            }
+        }
+        catch (error) {
+            await rm(temporary, { force: true });
+            throw error;
+        }
+    });
+}
+async function withRecordReservationLock(destination, operation) {
+    const lockPath = `${destination}.lock`;
+    let lock;
+    try {
+        lock = await open(lockPath, "wx", 0o600);
+    }
+    catch (error) {
+        throw new Error(`Attempt record "${destination}" is already reserved: ${errorMessage(error)}`);
+    }
+    try {
+        return await operation();
+    }
+    finally {
+        await lock.close();
+        await rm(lockPath, { force: true });
+    }
+}
+async function withRecordPublicationLock(destination, operation) {
+    const lockPath = `${destination}.write-lock`;
+    let lock;
+    try {
+        lock = await open(lockPath, "wx", 0o600);
+    }
+    catch (error) {
+        throw new Error(`Attempt record "${destination}" is already being published: ${errorMessage(error)}`);
+    }
+    try {
+        return await operation();
+    }
+    finally {
+        await lock.close();
+        await rm(lockPath, { force: true });
+    }
+}
+function syncDirectory(path) {
+    const directory = openSync(path, "r");
+    try {
+        fsyncSync(directory);
+    }
+    finally {
+        closeSync(directory);
+    }
+}
+async function writeFileHandleFully(handle, bytes, label) {
+    let offset = 0;
+    while (offset < bytes.length) {
+        const { bytesWritten } = await handle.write(bytes.subarray(offset));
+        if (bytesWritten <= 0)
+            throw new Error(`${label} write made no progress.`);
+        offset += bytesWritten;
+    }
+}
+export async function readAttemptRecord(path) {
+    const bytes = await readFile(resolve(path));
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    const value = JSON.parse(text);
+    assertRecord(value);
+    return value;
+}
+function readAttemptRecordSync(path) {
+    const bytes = readFileSync(resolve(path));
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    const value = JSON.parse(text);
+    assertRecord(value);
+    return value;
+}
+async function assertAttemptRecordPathAvailable(path, run, attempt) {
+    const destination = resolve(path);
+    let exists = false;
+    try {
+        await lstat(destination);
+        exists = true;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (!exists)
+        return;
+    const existing = await readAttemptRecord(destination);
+    if (existing.run.id !== run.id || existing.attempt.id !== attempt.id) {
+        throw new Error(`Attempt record "${path}" already belongs to another attempt.`);
+    }
+    throw new Error(`Attempt record "${path}" is already owned; use a new linked attempt.`);
+}
+async function reserveAttemptRecordPath(path) {
+    const reservation = `${resolve(path)}.lock`;
+    await mkdir(dirname(reservation), { recursive: true, mode: 0o700 });
+    let handle;
+    let created = false;
+    try {
+        handle = await open(reservation, "wx", 0o600);
+        created = true;
+        await writeFileHandleFully(handle, Buffer.from(`${process.pid}\n`, "utf8"), "Attempt record reservation");
+        await handle.sync();
+        return reservation;
+    }
+    catch (error) {
+        if (created)
+            await rm(reservation, { force: true });
+        throw new Error(`Attempt record "${path}" is already reserved: ${errorMessage(error)}`);
+    }
+    finally {
+        await handle?.close();
+    }
+}
+function validateOptions(options) {
+    createRunIdentity({
+        id: options.run.id,
+        taskId: options.run.taskId,
+        modelId: options.run.modelId,
+        harnessId: options.run.harnessId,
+    });
+    if (options.attempt !== undefined) {
+        createAttemptIdentity(options.run.id, options.attempt.number, options.attempt.id, options.attempt.retryOf);
+    }
+    if (options.assessmentMode !== undefined && options.assessmentMode !== "observational" && options.assessmentMode !== "verified") {
+        throw new Error("Assessment mode must be observational or verified.");
+    }
+    if (options.assessmentMode === "observational" && options.verifier !== undefined) {
+        throw new Error("Observational attempts cannot execute a verifier.");
+    }
+    if (!Number.isSafeInteger(options.maxWallClockMs) && options.maxWallClockMs !== undefined) {
+        throw new Error("Coordinator wall-clock budget must be a positive safe integer.");
+    }
+    if (options.maxWallClockMs !== undefined && options.maxWallClockMs < 1) {
+        throw new Error("Coordinator wall-clock budget must be a positive safe integer.");
+    }
+    if (!Number.isSafeInteger(options.harnessBudgetMs) && options.harnessBudgetMs !== undefined) {
+        throw new Error("Harness budget must be a positive safe integer.");
+    }
+    if (options.harnessBudgetMs !== undefined && options.harnessBudgetMs < 1) {
+        throw new Error("Harness budget must be a positive safe integer.");
+    }
+    if (!Number.isSafeInteger(options.shutdownGraceMs) && options.shutdownGraceMs !== undefined) {
+        throw new Error("Shutdown grace period must be a nonnegative safe integer.");
+    }
+    if (options.shutdownGraceMs !== undefined && options.shutdownGraceMs < 0) {
+        throw new Error("Shutdown grace period must be a nonnegative safe integer.");
+    }
+    for (const [label, milliseconds] of [
+        ["Coordinator wall-clock budget", options.maxWallClockMs],
+        ["Harness budget", options.harnessBudgetMs],
+        ["Shutdown grace period", options.shutdownGraceMs],
+    ]) {
+        if (milliseconds !== undefined && milliseconds > MAX_TIMER_MS) {
+            throw new Error(`${label} must not exceed the Node timer maximum.`);
+        }
+    }
+}
+function assertCheckpointDoesNotRegress(existing, incoming) {
+    const existingProgress = LIFECYCLE_PROGRESS[existing.lifecycle.state];
+    const incomingProgress = LIFECYCLE_PROGRESS[incoming.lifecycle.state];
+    if (incomingProgress < existingProgress || incoming.lifecycle.transitions.length < existing.lifecycle.transitions.length) {
+        throw new Error("Attempt record update regresses lifecycle progress.");
+    }
+    for (const [index, transition] of existing.lifecycle.transitions.entries()) {
+        const incomingTransition = incoming.lifecycle.transitions[index];
+        if (incomingTransition.from !== transition.from || incomingTransition.to !== transition.to || incomingTransition.at !== transition.at) {
+            throw new Error("Attempt record update changes retained lifecycle transitions.");
+        }
+    }
+    if (!sameJsonValue(existing.run, incoming.run) || !sameJsonValue(existing.attempt, incoming.attempt)
+        || existing.assessmentMode !== incoming.assessmentMode
+        || existing.lifecycle.createdAt !== incoming.lifecycle.createdAt) {
+        throw new Error("Attempt record update changes retained creation metadata.");
+    }
+    for (const field of [
+        "workspace",
+        "harness",
+        "verifier",
+        "harnessTerminationConfirmed",
+        "verifierTerminationConfirmed",
+        "cleanup",
+        "capture",
+    ]) {
+        if (existing[field] !== undefined && (incoming[field] === undefined || !sameJsonValue(existing[field], incoming[field]))) {
+            throw new Error(`Attempt record update changes retained ${field} evidence.`);
+        }
+    }
+}
+function sameJsonValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right)
+            && left.length === right.length
+            && left.every((value, index) => sameJsonValue(value, right[index]));
+    }
+    if (isRecord(left) || isRecord(right)) {
+        if (!isRecord(left) || !isRecord(right))
+            return false;
+        const leftKeys = Object.keys(left).sort();
+        const rightKeys = Object.keys(right).sort();
+        return leftKeys.length === rightKeys.length
+            && leftKeys.every((key, index) => key === rightKeys[index] && sameJsonValue(left[key], right[key]));
+    }
+    return false;
+}
+function classifyHarness(result, workspace) {
+    switch (result.status) {
+        case "completed":
+            return undefined;
+        case "failed":
+            return infrastructureClassification(result.failureClass === "task"
+                ? result.reason ?? "Harness reported task failure without verifier evidence."
+                : result.reason ?? "Harness failed.", "harness", workspace);
+        case "stopped":
+            if (result.stopReason === "policy")
+                return policyClassification(result.reason, workspace);
+            if (result.stopReason === "budget")
+                return budgetClassification("harness", result.reason, workspace);
+            return infrastructureClassification("Harness stopped without an explicit stop reason.", "harness", workspace);
+        case "interrupted":
+            return interruptedClassification(result.reason, "harness", workspace);
+    }
+}
+function classifyVerifier(result, workspace) {
+    switch (result.status) {
+        case "passed":
+            return completedClassification(workspace);
+        case "failed":
+            return taskClassification(result.error ?? "Verifier reported task failure.", workspace, "verifier");
+        case "error":
+            return verifierErrorClassification(result.error ?? "Verifier failed to execute.", workspace);
+        case "not-run":
+            return infrastructureClassification("Verifier did not run.", "verifier", workspace);
+    }
+}
+function completedClassification(workspace) {
+    if (workspace === undefined || workspace.status !== "ready" || workspace.retained === false
+        || workspace.artifactId === undefined) {
+        return infrastructureClassification("Completed run requires a retained workspace artifact.", "workspace", workspace);
+    }
+    return {
+        kind: "completed",
+        terminal: { state: "completed", failureClass: "none", stopReason: "none", workspaceArtifactId: workspace.artifactId },
+        source: "runner",
+    };
+}
+function taskClassification(reason, workspace, source) {
+    if (workspace === undefined || workspace.status !== "ready" || workspace.retained === false
+        || workspace.artifactId === undefined) {
+        return infrastructureClassification("Task failure requires a retained workspace artifact.", "workspace", workspace);
+    }
+    return {
+        kind: "task-failure",
+        terminal: { state: "failed", failureClass: "task", stopReason: "none", workspaceArtifactId: workspace.artifactId },
+        reason,
+        source,
+    };
+}
+function infrastructureClassification(reason, source, workspace) {
+    const workspaceArtifactId = retainedWorkspaceArtifactId(workspace);
+    return {
+        kind: source === "verifier" ? "verifier-error" : "infrastructure-failure",
+        terminal: { state: "failed", failureClass: "infrastructure", stopReason: "none", ...(workspaceArtifactId === undefined ? {} : { workspaceArtifactId }) },
+        reason,
+        source,
+    };
+}
+function verifierErrorClassification(reason, workspace) {
+    const workspaceArtifactId = retainedWorkspaceArtifactId(workspace);
+    return {
+        kind: "verifier-error",
+        terminal: { state: "failed", failureClass: "infrastructure", stopReason: "none", ...(workspaceArtifactId === undefined ? {} : { workspaceArtifactId }) },
+        reason,
+        source: "verifier",
+    };
+}
+function retainedWorkspaceArtifactId(workspace) {
+    return workspace !== undefined && workspace.retained !== false && workspace.artifactId !== undefined
+        && (workspace.status === "ready" || workspace.retained === true)
+        ? workspace.artifactId
+        : undefined;
+}
+function budgetClassification(source, reason, workspace) {
+    const workspaceArtifactId = retainedWorkspaceArtifactId(workspace);
+    return {
+        kind: "budget-stop",
+        terminal: { state: "stopped", failureClass: "none", stopReason: "budget", ...(workspaceArtifactId === undefined ? {} : { workspaceArtifactId }) },
+        ...(reason === undefined ? {} : { reason }),
+        source: source === "harness" ? "harness" : "runner",
+    };
+}
+function policyClassification(reason, workspace) {
+    const workspaceArtifactId = retainedWorkspaceArtifactId(workspace);
+    return {
+        kind: "policy-stop",
+        terminal: { state: "stopped", failureClass: "none", stopReason: "policy", ...(workspaceArtifactId === undefined ? {} : { workspaceArtifactId }) },
+        ...(reason === undefined ? {} : { reason }),
+        source: "harness",
+    };
+}
+function interruptedClassification(reason, source = "runner", workspace) {
+    const workspaceArtifactId = retainedWorkspaceArtifactId(workspace);
+    return {
+        kind: "interrupted",
+        terminal: { state: "interrupted", failureClass: "infrastructure", stopReason: "none", ...(workspaceArtifactId === undefined ? {} : { workspaceArtifactId }) },
+        ...(reason === undefined ? {} : { reason }),
+        source,
+    };
+}
+function abortClassification(cause, budget, reason, workspace) {
+    return cause === "interrupted"
+        ? interruptedClassification(reason, "runner", workspace)
+        : budgetClassification(budget ?? "coordinator", reason, workspace);
+}
+function classificationUnderlyingKind(classification) {
+    return classification.kind === "capture-incomplete"
+        ? classification.underlying ?? classification.kind
+        : classification.kind;
+}
+function snapshotWorkspace(workspace) {
+    assertWorkspaceResult(workspace);
+    assertJsonValue(workspace, "workspace", new Set());
+    return structuredClone(workspace);
+}
+function snapshotVerifier(verifier) {
+    assertVerifierResult(verifier);
+    assertJsonValue(verifier, "verifier", new Set());
+    return structuredClone(verifier);
+}
+async function shutdownHarness(result, independentShutdown, graceMs) {
+    const shutdownCallback = independentShutdown ?? result?.shutdown;
+    if (shutdownCallback === undefined)
+        return undefined;
+    let timer;
+    try {
+        const shutdown = Promise.resolve(shutdownCallback());
+        const settled = await Promise.race([
+            shutdown.then(() => ({ status: "completed" })),
+            new Promise((resolvePromise) => {
+                timer = setTimeout(() => resolvePromise({ status: "timed-out", error: "Harness shutdown exceeded its grace period." }), graceMs);
+            }),
+        ]);
+        return settled;
+    }
+    catch (error) {
+        return { status: "failed", error: errorMessage(error) };
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+async function shutdownWorkspace(shutdownCallback, graceMs) {
+    if (shutdownCallback === undefined)
+        return undefined;
+    let timer;
+    try {
+        const shutdown = Promise.resolve(shutdownCallback());
+        return await Promise.race([
+            shutdown.then(() => ({ status: "completed" }), (error) => ({ status: "failed", error: errorMessage(error) })),
+            new Promise((resolvePromise) => {
+                timer = setTimeout(() => resolvePromise({ status: "timed-out", error: "Workspace shutdown exceeded its grace period." }), graceMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+async function shutdownVerifier(shutdownCallback, graceMs) {
+    if (shutdownCallback === undefined)
+        return undefined;
+    let timer;
+    try {
+        const shutdown = Promise.resolve(shutdownCallback());
+        return await Promise.race([
+            shutdown.then(() => ({ status: "completed" }), (error) => ({ status: "failed", error: errorMessage(error) })),
+            new Promise((resolvePromise) => {
+                timer = setTimeout(() => resolvePromise({ status: "timed-out", error: "Verifier shutdown exceeded its grace period." }), graceMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        return { status: "failed", error: errorMessage(error) };
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function durableHarnessResult(result) {
+    const { shutdown: _shutdown, ...durable } = result;
+    assertHarnessResult(durable);
+    assertJsonValue(durable, "harness", new Set());
+    return structuredClone(durable);
+}
+function normalizeHarnessBudgetResult(result, budgetExpired) {
+    if (budgetExpired !== "harness" || result.status === "stopped" && result.stopReason === "budget")
+        return result;
+    const { status: nativeStatus, failureClass: nativeFailureClass, stopReason: nativeStopReason, reason: nativeReason, error: nativeError, evidence: nativeEvidence, ...rest } = result;
+    return {
+        ...rest,
+        status: "stopped",
+        stopReason: "budget",
+        reason: nativeReason ?? nativeError ?? "Harness result arrived after its budget deadline.",
+        evidence: {
+            nativeStatus,
+            ...(nativeFailureClass === undefined ? {} : { nativeFailureClass }),
+            ...(nativeStopReason === undefined ? {} : { nativeStopReason }),
+            ...(nativeError === undefined ? {} : { nativeError }),
+            ...(nativeEvidence === undefined ? {} : { nativeEvidence }),
+        },
+    };
+}
+function normalizeHarnessShutdownFailure(result) {
+    if (result.status !== "completed" || result.shutdownResult === undefined || result.shutdownResult.status === "completed")
+        return result;
+    return {
+        ...result,
+        status: "failed",
+        failureClass: "infrastructure",
+        reason: result.reason ?? "Harness shutdown did not complete.",
+        evidence: {
+            nativeStatus: "completed",
+            ...(result.evidence === undefined ? {} : { nativeEvidence: result.evidence }),
+        },
+    };
+}
+function normalizeVerifierShutdownFailure(result) {
+    if ((result.status !== "passed" && result.status !== "failed")
+        || result.shutdownResult === undefined || result.shutdownResult.status === "completed")
+        return result;
+    return {
+        ...result,
+        status: "error",
+        error: result.error ?? "Verifier shutdown did not complete.",
+        evidence: {
+            nativeStatus: result.status,
+            ...(result.evidence === undefined ? {} : { nativeEvidence: result.evidence }),
+        },
+    };
+}
+async function settleWithTimeout(promise, milliseconds) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise.then((value) => ({ status: "completed", value }), (error) => ({ status: "failed", error })),
+            new Promise((resolvePromise) => {
+                timer = setTimeout(() => resolvePromise({ status: "timed-out", error: "Operation exceeded its cancellation grace period." }), milliseconds);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function assertIdentity(value, label) {
+    if (typeof value !== "string" || value.trim() === "" || [...value].length > 256) {
+        throw new Error(`${label} must be a non-empty identifier of at most 256 characters.`);
+    }
+}
+function assertRecord(value) {
+    if (!isRecord(value)) {
+        throw new Error("Attempt record must be a JSON object.");
+    }
+    assertJsonValue(value, "attempt record", new Set());
+    if (value.schemaVersion !== "ebo.attempt/v1")
+        throw new Error("Attempt record schemaVersion is invalid.");
+    if (value.assessmentMode === undefined)
+        value.assessmentMode = "verified";
+    if (value.assessmentMode !== "observational" && value.assessmentMode !== "verified") {
+        throw new Error("Attempt record assessment mode is invalid.");
+    }
+    const run = value.run;
+    if (!isRecord(run))
+        throw new Error("Attempt record run is invalid.");
+    assertIdentityValue(run.id, "Run ID");
+    assertIdentityValue(run.taskId, "Task ID");
+    assertIdentityValue(run.modelId, "Model ID");
+    assertIdentityValue(run.harnessId, "Harness ID");
+    const attempt = value.attempt;
+    if (!isRecord(attempt))
+        throw new Error("Attempt record attempt is invalid.");
+    assertIdentityValue(attempt.id, "Attempt ID");
+    const attemptNumber = typeof attempt.number === "number" ? attempt.number : NaN;
+    if (!Number.isSafeInteger(attemptNumber) || attemptNumber < 1)
+        throw new Error("Attempt number is invalid.");
+    if (attempt.retryOf !== undefined)
+        assertIdentityValue(attempt.retryOf, "Retry attempt ID");
+    if ((attemptNumber > 1) !== (attempt.retryOf !== undefined))
+        throw new Error("Attempt retry lineage is invalid.");
+    if (attempt.retryOf === attempt.id)
+        throw new Error("Attempt retry lineage is self-referential.");
+    const lifecycle = value.lifecycle;
+    if (!isRecord(lifecycle))
+        throw new Error("Attempt record lifecycle is invalid.");
+    if (!isLifecycleState(lifecycle.state))
+        throw new Error("Attempt lifecycle state is invalid.");
+    assertTimestampValue(lifecycle.createdAt, "Lifecycle createdAt");
+    assertTimestampValue(lifecycle.startedAt, "Lifecycle startedAt");
+    if (lifecycle.endedAt !== undefined)
+        assertTimestampValue(lifecycle.endedAt, "Lifecycle endedAt");
+    if (!isRecord(lifecycle.timestamps))
+        throw new Error("Lifecycle timestamps are invalid.");
+    if (!Array.isArray(lifecycle.transitions))
+        throw new Error("Lifecycle transitions are invalid.");
+    let state = "created";
+    const visitedStates = new Set(["created"]);
+    for (const transition of lifecycle.transitions) {
+        if (!isRecord(transition) || !isLifecycleState(transition.from) || !isLifecycleState(transition.to)) {
+            throw new Error("Lifecycle transition is invalid.");
+        }
+        assertTimestampValue(transition.at, "Lifecycle transition timestamp");
+        if (transition.from !== state || !ALLOWED_TRANSITIONS[state].includes(transition.to)) {
+            throw new Error("Lifecycle transition sequence is invalid.");
+        }
+        state = transition.to;
+        visitedStates.add(state);
+    }
+    if (state !== lifecycle.state)
+        throw new Error("Lifecycle state does not match its transitions.");
+    for (const [timestampState, timestamp] of Object.entries(lifecycle.timestamps)) {
+        if (!isLifecycleState(timestampState))
+            throw new Error("Lifecycle timestamp state is invalid.");
+        if (!visitedStates.has(timestampState))
+            throw new Error("Lifecycle timestamp state is not present in its transitions.");
+        assertTimestampValue(timestamp, `Lifecycle timestamp ${timestampState}`);
+    }
+    for (const visitedState of visitedStates) {
+        if (lifecycle.timestamps[visitedState] === undefined)
+            throw new Error(`Lifecycle timestamp ${visitedState} is missing.`);
+    }
+    for (const transition of lifecycle.transitions) {
+        if (lifecycle.timestamps[transition.to] !== transition.at) {
+            throw new Error("Lifecycle transition timestamp disagrees with its state timestamp.");
+        }
+    }
+    if (lifecycle.timestamps.created !== lifecycle.createdAt)
+        throw new Error("Lifecycle created timestamp is inconsistent.");
+    if (lifecycle.startedAt !== (lifecycle.timestamps.setup ?? lifecycle.createdAt)) {
+        throw new Error("Lifecycle started timestamp is inconsistent.");
+    }
+    if (visitedStates.has("terminal")) {
+        if (lifecycle.endedAt === undefined || lifecycle.endedAt !== lifecycle.timestamps.terminal) {
+            throw new Error("Lifecycle ended timestamp is inconsistent.");
+        }
+    }
+    else if (lifecycle.endedAt !== undefined) {
+        throw new Error("Lifecycle ended timestamp is present before terminal state.");
+    }
+    if (typeof value.partial !== "boolean")
+        throw new Error("Attempt record partial state is invalid.");
+    if (lifecycle.state !== "terminal" && value.partial !== true) {
+        throw new Error("Nonterminal attempt records must remain partial.");
+    }
+    const workspaceShutdownFailed = isRecord(value.workspace)
+        && isRecord(value.workspace.shutdownResult)
+        && value.workspace.shutdownResult.status !== "completed";
+    if (isRecord(value.workspace)
+        && (value.workspace.status === "failed" || workspaceShutdownFailed)
+        && (visitedStates.has("running") || visitedStates.has("verifying"))) {
+        throw new Error("Workspace failure records cannot include execution lifecycle phases.");
+    }
+    if ((value.verifier !== undefined || value.verifierTerminationConfirmed !== undefined)
+        && !visitedStates.has("verifying")) {
+        throw new Error("Verifier evidence requires the verifying lifecycle phase.");
+    }
+    if (value.assessmentMode === "observational"
+        && (visitedStates.has("verifying") || value.verifier !== undefined || value.verifierTerminationConfirmed !== undefined)) {
+        throw new Error("Observational attempt records cannot contain verifier execution evidence.");
+    }
+    if (value.harnessTerminationConfirmed !== undefined && typeof value.harnessTerminationConfirmed !== "boolean") {
+        throw new Error("Harness termination confirmation is invalid.");
+    }
+    if (value.verifierTerminationConfirmed !== undefined && typeof value.verifierTerminationConfirmed !== "boolean") {
+        throw new Error("Verifier termination confirmation is invalid.");
+    }
+    if (value.workspace !== undefined)
+        assertWorkspaceResult(value.workspace);
+    if (value.harness !== undefined)
+        assertHarnessResult(value.harness);
+    if (value.verifier !== undefined)
+        assertVerifierResult(value.verifier);
+    assertTerminationConfirmation(value.harness, value.harnessTerminationConfirmed, "Harness");
+    assertTerminationConfirmation(value.verifier, value.verifierTerminationConfirmed, "Verifier");
+    if (value.terminal !== undefined)
+        assertTerminalRecord(value.terminal);
+    if ((value.terminal === undefined) !== (value.classification === undefined)) {
+        throw new Error("Attempt terminal and classification records must be paired.");
+    }
+    if (lifecycle.state === "terminal" && value.terminal === undefined) {
+        throw new Error("Terminal attempt records require terminal and classification outcomes.");
+    }
+    if (value.terminal !== undefined && lifecycle.state !== "terminal") {
+        throw new Error("Terminal attempt records must have terminal lifecycle state.");
+    }
+    if (value.classification !== undefined) {
+        if (!isRecord(value.classification) || !isClassificationKind(value.classification.kind)) {
+            throw new Error("Attempt classification is invalid.");
+        }
+        if (value.classification.reason !== undefined)
+            assertTimestampValue(value.classification.reason, "Classification reason");
+        if (value.classification.source !== undefined && !["runner", "workspace", "harness", "verifier", "cleanup", "capture"].includes(String(value.classification.source))) {
+            throw new Error("Classification source is invalid.");
+        }
+        if (value.classification.underlyingSource !== undefined
+            && !["runner", "workspace", "harness", "verifier", "cleanup", "capture"].includes(String(value.classification.underlyingSource))) {
+            throw new Error("Classification underlying source is invalid.");
+        }
+        if (value.classification.underlying !== undefined) {
+            if (value.classification.kind !== "capture-incomplete" || !isClassificationKind(value.classification.underlying)
+                || value.classification.underlying === "capture-incomplete") {
+                throw new Error("Classification underlying outcome is invalid.");
+            }
+        }
+        else if (value.classification.underlyingSource !== undefined) {
+            throw new Error("Classification underlying source requires a wrapped outcome.");
+        }
+        if (value.classification.kind === "capture-incomplete" && value.classification.source !== "capture") {
+            throw new Error("Capture-incomplete classifications require capture attribution.");
+        }
+        assertTerminalRecord(value.classification.terminal);
+        if (!sameTerminalRecord(value.terminal, value.classification.terminal)) {
+            throw new Error("Attempt terminal and classification records disagree.");
+        }
+        assertClassificationTerminal(value.classification.kind, value.classification.terminal, value.classification.underlying);
+        const classificationKind = value.classification.kind === "capture-incomplete"
+            ? value.classification.underlying
+            : value.classification.kind;
+        const classificationSource = value.classification.kind === "capture-incomplete"
+            ? value.classification.underlyingSource
+            : value.classification.source;
+        if (classificationKind === "policy-stop") {
+            if (classificationSource !== "harness") {
+                throw new Error("Policy-stop terminal records require harness attribution.");
+            }
+            if (!visitedStates.has("running")) {
+                throw new Error("Policy-stop terminal records require the running lifecycle phase.");
+            }
+            if (!isRecord(value.workspace) || value.workspace.status !== "ready") {
+                throw new Error("Policy-stop terminal records require a ready workspace result.");
+            }
+            assertShutdownCompleted(value.workspace, "Workspace");
+            if (!isRecord(value.harness) || value.harness.status !== "stopped" || value.harness.stopReason !== "policy") {
+                throw new Error("Policy-stop terminal records require a matching stopped harness result.");
+            }
+        }
+        if (classificationKind === "budget-stop") {
+            if (classificationSource !== "runner" && classificationSource !== "harness") {
+                throw new Error("Budget-stop terminal records require runner or harness attribution.");
+            }
+            if (classificationSource === "runner") {
+                // Coordinator budgets do not require a harness result when the harness
+                // was never started.
+            }
+            else {
+                if (!visitedStates.has("running")) {
+                    throw new Error("Harness budget-stop terminal records require the running lifecycle phase.");
+                }
+                if (!isRecord(value.workspace) || value.workspace.status !== "ready") {
+                    throw new Error("Harness budget-stop terminal records require a ready workspace result.");
+                }
+                assertShutdownCompleted(value.workspace, "Workspace");
+                if (!isRecord(value.harness)
+                    || !((value.harness.status === "stopped" && value.harness.stopReason === "budget")
+                        || value.harness.status === "interrupted")) {
+                    throw new Error("Harness budget-stop terminal records require compatible harness evidence.");
+                }
+            }
+        }
+        if (classificationKind === "interrupted" && classificationSource === "harness") {
+            if (!visitedStates.has("running")) {
+                throw new Error("Harness interruption terminal records require the running lifecycle phase.");
+            }
+            if (!isRecord(value.workspace) || value.workspace.status !== "ready") {
+                throw new Error("Harness interruption terminal records require a ready workspace result.");
+            }
+            assertShutdownCompleted(value.workspace, "Workspace");
+            if (!isRecord(value.harness) || value.harness.status !== "interrupted") {
+                throw new Error("Harness interruption terminal records require an interrupted harness result.");
+            }
+        }
+        if (classificationKind === "interrupted" && classificationSource !== "runner" && classificationSource !== "harness") {
+            throw new Error("Interrupted terminal records require runner or harness attribution.");
+        }
+        if (classificationKind === "infrastructure-failure"
+            && classificationSource !== "runner" && classificationSource !== "workspace"
+            && classificationSource !== "harness" && classificationSource !== "cleanup") {
+            throw new Error("Infrastructure-failure terminal records have an invalid attribution.");
+        }
+        if (classificationKind === "infrastructure-failure" && classificationSource === "harness") {
+            if (!visitedStates.has("running")) {
+                throw new Error("Harness infrastructure-failure records require the running lifecycle phase.");
+            }
+            if (!isRecord(value.workspace) || value.workspace.status !== "ready") {
+                throw new Error("Harness infrastructure-failure records require a ready workspace result.");
+            }
+            assertShutdownCompleted(value.workspace, "Workspace");
+            if (!isRecord(value.harness)
+                || !(value.harness.status === "failed"
+                    || value.harness.status === "stopped" && value.harness.stopReason === undefined)) {
+                throw new Error("Harness infrastructure-failure records require a failed or unreasoned stopped harness result.");
+            }
+        }
+        if (classificationKind === "infrastructure-failure" && classificationSource === "workspace") {
+            if (!visitedStates.has("setup")) {
+                throw new Error("Workspace infrastructure-failure records require the setup lifecycle phase.");
+            }
+            if (!isRecord(value.workspace) || (value.workspace.status !== "ready" && value.workspace.status !== "failed")) {
+                throw new Error("Workspace infrastructure-failure records require a native workspace result.");
+            }
+            if (value.workspace.status === "ready" && !workspaceShowsFailure(value.workspace)) {
+                throw new Error("Workspace infrastructure-failure records require workspace failure evidence.");
+            }
+        }
+        if (classificationKind === "infrastructure-failure" && classificationSource === "cleanup") {
+            if (!isRecord(value.cleanup) || (value.cleanup.status !== "failed" && value.cleanup.status !== "timed-out")) {
+                throw new Error("Cleanup infrastructure-failure records require failed or timed-out cleanup evidence.");
+            }
+        }
+        if (classificationKind === "task-failure" && classificationSource !== "verifier") {
+            throw new Error("Task-failure terminal records require verifier attribution.");
+        }
+        if (classificationKind === "completed" && classificationSource !== "runner") {
+            throw new Error("Completed terminal records require runner attribution.");
+        }
+        if (classificationKind === "verifier-error") {
+            if (classificationSource !== "verifier") {
+                throw new Error("Verifier-error terminal records require verifier attribution.");
+            }
+            if (!visitedStates.has("running") || !visitedStates.has("verifying")) {
+                throw new Error("Verifier-error terminal records require running and verifying lifecycle phases.");
+            }
+            if (!isRecord(value.harness) || value.harness.status !== "completed") {
+                throw new Error("Verifier-error terminal records require a completed harness result.");
+            }
+            if (!isRecord(value.workspace) || value.workspace.status !== "ready") {
+                throw new Error("Verifier-error terminal records require a ready workspace result.");
+            }
+            assertShutdownCompleted(value.workspace, "Workspace");
+            if (!isRecord(value.verifier) || (value.verifier.status !== "error" && value.verifier.status !== "not-run")) {
+                throw new Error("Verifier-error terminal records require an error or not-run verifier result.");
+            }
+            assertShutdownCompleted(value.harness, "Harness");
+            if (value.harnessTerminationConfirmed === false) {
+                throw new Error("Verifier-error terminal records require confirmed harness termination.");
+            }
+        }
+        const expectedPartial = classificationUnderlyingKind(value.classification) !== "completed"
+            || isRecord(value.capture) && value.capture.status === "incomplete";
+        if (value.partial !== expectedPartial)
+            throw new Error("Attempt partial state contradicts its terminal outcome.");
+    }
+    const retainedArtifactId = retainedRecordWorkspaceArtifactId(value.workspace);
+    if (retainedArtifactId !== undefined && value.terminal !== undefined
+        && value.terminal.workspaceArtifactId !== retainedArtifactId) {
+        throw new Error("Retained workspace evidence must be linked from the terminal outcome.");
+    }
+    if (value.terminal?.workspaceArtifactId !== undefined) {
+        assertTerminalWorkspaceEvidence(value.workspace, value.terminal.workspaceArtifactId, value.terminal.state === "failed" && value.terminal.failureClass === "infrastructure"
+            || value.terminal.state === "stopped"
+            || value.terminal.state === "interrupted");
+    }
+    if (value.terminal?.state === "completed") {
+        if (!visitedStates.has("running") || value.assessmentMode === "verified" && !visitedStates.has("verifying")) {
+            throw new Error("Completed terminal records require their assessment lifecycle phases.");
+        }
+        assertHarnessStatus(value.harness, "completed");
+        assertCleanupStatus(value.cleanup, "completed");
+        if (value.harnessTerminationConfirmed === false
+            || value.assessmentMode === "verified" && value.verifierTerminationConfirmed === false) {
+            throw new Error("Completed terminal records require confirmed execution termination.");
+        }
+        assertShutdownCompleted(value.workspace, "Workspace");
+        assertShutdownCompleted(value.harness, "Harness");
+        if (value.assessmentMode === "verified")
+            assertShutdownCompleted(value.verifier, "Verifier");
+        if (isRecord(value.persistence) && value.persistence.status !== "complete") {
+            throw new Error("Completed terminal records cannot have incomplete persistence.");
+        }
+        assertTerminalWorkspaceEvidence(value.workspace, value.terminal.workspaceArtifactId);
+        if (value.assessmentMode === "verified")
+            assertVerifierStatus(value.verifier, "passed");
+    }
+    if (value.terminal?.state === "failed" && value.terminal.failureClass === "task") {
+        if (!visitedStates.has("running") || !visitedStates.has("verifying")) {
+            throw new Error("Task-failure terminal records require running and verifying lifecycle phases.");
+        }
+        assertHarnessStatus(value.harness, "completed");
+        assertShutdownCompleted(value.workspace, "Workspace");
+        assertShutdownCompleted(value.harness, "Harness");
+        assertShutdownCompleted(value.verifier, "Verifier");
+        if (value.harnessTerminationConfirmed === false || value.verifierTerminationConfirmed === false) {
+            throw new Error("Task-failure terminal records require confirmed execution termination.");
+        }
+        assertTerminalWorkspaceEvidence(value.workspace, value.terminal.workspaceArtifactId);
+        assertVerifierStatus(value.verifier, "failed");
+    }
+    if (isRecord(value.capture) && value.capture.status === "incomplete" && value.partial !== true) {
+        throw new Error("Incomplete capture requires partial attempt state.");
+    }
+    for (const field of ["capture", "persistence"]) {
+        const status = value[field];
+        if (status !== undefined) {
+            if (!isRecord(status) || !["complete", "incomplete"].includes(String(status.status))) {
+                throw new Error(`Attempt ${field} status is invalid.`);
+            }
+            if (status.error !== undefined)
+                assertTimestampValue(status.error, `Attempt ${field} error`);
+        }
+    }
+    if (value.cleanup !== undefined) {
+        if (!isRecord(value.cleanup) || !["completed", "failed", "timed-out"].includes(String(value.cleanup.status))) {
+            throw new Error("Attempt cleanup status is invalid.");
+        }
+        if (value.cleanup.error !== undefined)
+            assertTimestampValue(value.cleanup.error, "Attempt cleanup error");
+    }
+    if (lifecycle.state === "terminal" && (!isRecord(value.cleanup) || !["completed", "failed", "timed-out"].includes(String(value.cleanup.status)))) {
+        throw new Error("Terminal attempt records require explicit cleanup status.");
+    }
+    if (lifecycle.state === "terminal" && isRecord(value.cleanup) && value.cleanup.status === "completed") {
+        if (value.harnessTerminationConfirmed === false || value.verifierTerminationConfirmed === false) {
+            throw new Error("Completed cleanup requires confirmed execution termination.");
+        }
+        assertShutdownCompleted(value.workspace, "Workspace");
+        assertShutdownCompleted(value.harness, "Harness");
+        assertShutdownCompleted(value.verifier, "Verifier");
+    }
+    if (lifecycle.state === "terminal"
+        && (!isRecord(value.capture) || !["complete", "incomplete"].includes(String(value.capture.status)))) {
+        throw new Error("Terminal attempt records require explicit capture status.");
+    }
+    if (value.classification?.kind === "capture-incomplete"
+        && (!isRecord(value.capture) || value.capture.status !== "incomplete" || value.partial !== true)) {
+        throw new Error("Capture-incomplete classifications require incomplete capture evidence and partial state.");
+    }
+    if (lifecycle.state === "terminal" && isRecord(value.capture) && value.capture.status === "incomplete"
+        && value.classification?.kind !== "capture-incomplete") {
+        throw new Error("Incomplete terminal capture requires a capture-incomplete classification.");
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function assertJsonValue(value, path, seen) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} must be a finite JSON number.`);
+        return;
+    }
+    if (typeof value !== "object")
+        throw new Error(`${path} contains a non-JSON value.`);
+    if (seen.has(value))
+        throw new Error(`${path} contains a cycle.`);
+    seen.add(value);
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertJsonValue(item, `${path}[${index}]`, seen));
+    }
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null)
+            throw new Error(`${path} must be a JSON object or array.`);
+        const object = value;
+        for (const key of Object.keys(object))
+            assertJsonValue(object[key], `${path}.${key}`, seen);
+    }
+    seen.delete(value);
+}
+function assertIdentityValue(value, label) {
+    if (typeof value !== "string")
+        throw new Error(`${label} is invalid.`);
+    assertIdentity(value, label);
+}
+function assertTimestampValue(value, label) {
+    if (typeof value !== "string" || value.trim() === "")
+        throw new Error(`${label} is invalid.`);
+}
+function isLifecycleState(value) {
+    return typeof value === "string" && Object.hasOwn(ALLOWED_TRANSITIONS, value);
+}
+function isClassificationKind(value) {
+    return ["completed", "task-failure", "infrastructure-failure", "verifier-error", "budget-stop", "policy-stop", "interrupted", "capture-incomplete"].includes(String(value));
+}
+function assertTerminalRecord(value) {
+    if (!isRecord(value) || !["completed", "failed", "stopped", "interrupted"].includes(String(value.state))) {
+        throw new Error("Attempt terminal record is invalid.");
+    }
+    if (!["none", "infrastructure", "task"].includes(String(value.failureClass))) {
+        throw new Error("Attempt terminal failure class is invalid.");
+    }
+    if (!["none", "budget", "policy"].includes(String(value.stopReason))) {
+        throw new Error("Attempt terminal stop reason is invalid.");
+    }
+    if (value.workspaceArtifactId !== undefined)
+        assertIdentityValue(value.workspaceArtifactId, "Workspace artifact ID");
+    if (value.state === "completed" && (value.failureClass !== "none" || value.stopReason !== "none" || value.workspaceArtifactId === undefined)) {
+        throw new Error("Completed terminal record is incomplete.");
+    }
+    if (value.state === "failed" && (value.failureClass !== "infrastructure" && value.failureClass !== "task" || value.stopReason !== "none" || value.failureClass === "task" && value.workspaceArtifactId === undefined)) {
+        throw new Error("Failed terminal record is invalid.");
+    }
+    if (value.state === "stopped" && (value.failureClass !== "none" || (value.stopReason !== "budget" && value.stopReason !== "policy"))) {
+        throw new Error("Stopped terminal record is invalid.");
+    }
+    if (value.state === "interrupted" && (value.failureClass !== "infrastructure" || value.stopReason !== "none")) {
+        throw new Error("Interrupted terminal record is invalid.");
+    }
+}
+function sameTerminalRecord(left, right) {
+    if (!isRecord(left) || !isRecord(right))
+        return false;
+    return left.state === right.state
+        && left.failureClass === right.failureClass
+        && left.stopReason === right.stopReason
+        && left.workspaceArtifactId === right.workspaceArtifactId;
+}
+function assertTerminalWorkspaceEvidence(workspace, artifactId, allowFailed = false) {
+    if (!isRecord(workspace) || (workspace.status !== "ready" && !(allowFailed && workspace.status === "failed" && workspace.retained === true)) || workspace.retained === false
+        || typeof workspace.artifactId !== "string" || artifactId === undefined || workspace.artifactId !== artifactId) {
+        throw new Error("Terminal outcome requires matching retained workspace evidence.");
+    }
+}
+function retainedRecordWorkspaceArtifactId(workspace) {
+    if (!isRecord(workspace) || workspace.retained === false || typeof workspace.artifactId !== "string")
+        return undefined;
+    return workspace.status === "ready" || workspace.retained === true ? workspace.artifactId : undefined;
+}
+function workspaceShowsFailure(workspace) {
+    return workspace.error !== undefined
+        || workspace.artifactId === undefined
+        || workspace.retained === false
+        || isRecord(workspace.shutdownResult) && workspace.shutdownResult.status !== "completed";
+}
+function assertWorkspaceResult(value) {
+    if (!isRecord(value) || value.status !== "ready" && value.status !== "failed") {
+        throw new Error("Attempt workspace evidence is invalid.");
+    }
+    for (const field of ["path", "artifactId", "digest", "error"]) {
+        if (value[field] !== undefined)
+            assertTimestampValue(value[field], `Workspace ${field}`);
+    }
+    if (value.retained !== undefined && typeof value.retained !== "boolean")
+        throw new Error("Workspace retention is invalid.");
+    if (value.shutdownResult !== undefined)
+        assertShutdownResult(value.shutdownResult, "Workspace shutdown");
+}
+function assertHarnessResult(value) {
+    if (!isRecord(value) || !["completed", "failed", "stopped", "interrupted"].includes(String(value.status))) {
+        throw new Error("Attempt harness evidence is invalid.");
+    }
+    if (value.status === "completed" && (value.failureClass !== undefined || value.stopReason !== undefined)) {
+        throw new Error("Completed harness evidence cannot include failure or stop fields.");
+    }
+    if (value.status === "failed" && value.stopReason !== undefined) {
+        throw new Error("Failed harness evidence cannot include a stop field.");
+    }
+    if (value.status === "stopped" && value.failureClass !== undefined) {
+        throw new Error("Stopped harness evidence cannot include a failure field.");
+    }
+    if (value.status === "interrupted" && (value.failureClass !== undefined || value.stopReason !== undefined)) {
+        throw new Error("Interrupted harness evidence cannot include failure or stop fields.");
+    }
+    if (value.failureClass !== undefined && !["infrastructure", "task"].includes(String(value.failureClass))) {
+        throw new Error("Harness failure class is invalid.");
+    }
+    if (value.stopReason !== undefined && !["budget", "policy"].includes(String(value.stopReason))) {
+        throw new Error("Harness stop reason is invalid.");
+    }
+    for (const field of ["reason", "error", "captureError"]) {
+        if (value[field] !== undefined)
+            assertTimestampValue(value[field], `Harness ${field}`);
+    }
+    if (value.shutdownResult !== undefined)
+        assertShutdownResult(value.shutdownResult, "Harness shutdown");
+}
+function assertVerifierResult(value) {
+    if (!isRecord(value) || !["passed", "failed", "error", "not-run"].includes(String(value.status))) {
+        throw new Error("Attempt verifier evidence is invalid.");
+    }
+    if (value.status === "passed" && value.error !== undefined) {
+        throw new Error("Passed verifier evidence cannot include an error.");
+    }
+    if (value.error !== undefined)
+        assertTimestampValue(value.error, "Verifier error");
+    if (value.shutdownResult !== undefined)
+        assertShutdownResult(value.shutdownResult, "Verifier shutdown");
+}
+function assertShutdownResult(value, label) {
+    if (!isRecord(value) || !["completed", "failed", "timed-out"].includes(String(value.status))) {
+        throw new Error(`${label} result is invalid.`);
+    }
+    if (value.error !== undefined)
+        assertTimestampValue(value.error, `${label} error`);
+}
+function assertTerminationConfirmation(value, confirmation, label) {
+    if (!isRecord(value) || typeof confirmation !== "boolean" || !isRecord(value.shutdownResult))
+        return;
+    const shutdownStatus = value.shutdownResult.status;
+    if (confirmation && shutdownStatus !== "completed") {
+        throw new Error(`${label} termination confirmation contradicts its shutdown result.`);
+    }
+    if (!confirmation && shutdownStatus === "completed") {
+        throw new Error(`${label} termination confirmation contradicts its shutdown result.`);
+    }
+}
+function assertVerifierStatus(verifier, status) {
+    if (!isRecord(verifier) || verifier.status !== status) {
+        throw new Error(`Terminal outcome requires a ${status} verifier result.`);
+    }
+}
+function assertHarnessStatus(harness, status) {
+    if (!isRecord(harness) || harness.status !== status) {
+        throw new Error(`Terminal outcome requires a ${status} harness result.`);
+    }
+}
+function assertCleanupStatus(cleanup, status) {
+    if (!isRecord(cleanup) || cleanup.status !== status) {
+        throw new Error(`Terminal outcome requires ${status} cleanup.`);
+    }
+}
+function assertShutdownCompleted(value, label) {
+    if (isRecord(value) && isRecord(value.shutdownResult) && value.shutdownResult.status !== "completed") {
+        throw new Error(`Completed terminal records require confirmed ${label.toLowerCase()} shutdown.`);
+    }
+}
+function assertClassificationTerminal(kind, terminal, underlying) {
+    const baseKind = kind === "capture-incomplete" ? underlying : kind;
+    if (!isClassificationKind(baseKind) || baseKind === "capture-incomplete") {
+        throw new Error("Capture-incomplete classification must name a concrete underlying outcome.");
+    }
+    const expected = baseKind === "completed"
+        ? { state: "completed", failureClass: "none", stopReason: "none" }
+        : baseKind === "task-failure"
+            ? { state: "failed", failureClass: "task", stopReason: "none" }
+            : baseKind === "infrastructure-failure" || baseKind === "verifier-error"
+                ? { state: "failed", failureClass: "infrastructure", stopReason: "none" }
+                : baseKind === "budget-stop"
+                    ? { state: "stopped", failureClass: "none", stopReason: "budget" }
+                    : baseKind === "policy-stop"
+                        ? { state: "stopped", failureClass: "none", stopReason: "policy" }
+                        : { state: "interrupted", failureClass: "infrastructure", stopReason: "none" };
+    if (terminal.state !== expected.state || terminal.failureClass !== expected.failureClass || terminal.stopReason !== expected.stopReason) {
+        throw new Error("Attempt classification kind does not match its terminal outcome.");
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}