import { z } from "zod";
import { type LearningTextAsset } from "@openpond/evals/learning";
import type { TasksetRelease } from "@openpond/evals/tasksets";
import { ModelProjectVersionedRefSchema } from "./model-projects.js";
export { NativeHarnessExperimentAttemptSchema, verifyNativeHarnessExperimentAttempt, type NativeHarnessExperimentAttempt, } from "@openpond/evals/experiments";
export declare const ModelStarterEnvironmentAttemptSchema: z.ZodObject<{
    schemaVersion: z.ZodLiteral<"openpond.javascriptEnvironmentAttempt.v1">;
    taskId: z.ZodString;
    status: z.ZodEnum<{
        budget_exhausted: "budget_exhausted";
        cancelled: "cancelled";
        completed: "completed";
        environment_failure: "environment_failure";
        policy_failure: "policy_failure";
        timed_out: "timed_out";
    }>;
    output: z.ZodNullable<z.ZodString>;
    collected: z.ZodBoolean;
    environmentCleanupComplete: z.ZodBoolean;
    snapshot: z.ZodNullable<z.ZodObject<{
        definition: z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
            revision: z.ZodNumber;
        }, z.core.$strict>;
        inputHash: z.ZodString;
        seed: z.ZodNumber;
        initialStateHash: z.ZodString;
        finalStateHash: z.ZodString;
        state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        events: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strict>>;
    messages: z.ZodArray<z.ZodUnknown>;
    error: z.ZodNullable<z.ZodString>;
    contentHash: z.ZodString;
}, z.core.$strict>;
/** Validate an owner-recorded runtime artifact against the admitted task.
 * Provenance/ownership of the artifact remains the execution host's concern. */
export declare function verifyModelStarterEnvironmentAttempt(value: unknown, context: {
    taskId: string;
    input: Record<string, unknown>;
    seed: number;
    javascript: z.infer<typeof ModelProjectVersionedRefSchema>;
}): {
    schemaVersion: "openpond.javascriptEnvironmentAttempt.v1";
    taskId: string;
    status: "budget_exhausted" | "cancelled" | "completed" | "environment_failure" | "policy_failure" | "timed_out";
    output: string | null;
    collected: boolean;
    environmentCleanupComplete: boolean;
    snapshot: {
        definition: {
            id: string;
            contentHash: string;
            revision: number;
        };
        inputHash: string;
        seed: number;
        initialStateHash: string;
        finalStateHash: string;
        state: Record<string, unknown>;
        events: Record<string, unknown>[];
    } | null;
    messages: unknown[];
    error: string | null;
    contentHash: string;
};
export declare const ModelStarterExecutionSchema: z.ZodObject<{
    environment: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.environmentRelease.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        contract: z.ZodObject<{
            protocolVersion: z.ZodLiteral<"openpond.environment.v1">;
            kind: z.ZodEnum<{
                agent: "agent";
                custom_program: "custom_program";
                text: "text";
                work: "work";
            }>;
            entrypoint: z.ZodString;
            stateful: z.ZodBoolean;
            deterministicSeeds: z.ZodBoolean;
            lifecycle: z.ZodArray<z.ZodEnum<{
                collect: "collect";
                create: "create";
                destroy: "destroy";
                reset: "reset";
                step: "step";
            }>>;
            networkPolicy: z.ZodEnum<{
                declared_read_only: "declared_read_only";
                declared_scoped: "declared_scoped";
                none: "none";
            }>;
            defaultTimeoutMs: z.ZodNumber;
        }, z.core.$strict>;
        actionSchemaRef: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            path: z.ZodString;
            contentHash: z.ZodString;
            sizeBytes: z.ZodNumber;
            mediaType: z.ZodString;
            visibility: z.ZodEnum<{
                host_private: "host_private";
                policy: "policy";
                verifier: "verifier";
            }>;
        }, z.core.$strict>>;
        observationSchemaRef: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            path: z.ZodString;
            contentHash: z.ZodString;
            sizeBytes: z.ZodNumber;
            mediaType: z.ZodString;
            visibility: z.ZodEnum<{
                host_private: "host_private";
                policy: "policy";
                verifier: "verifier";
            }>;
        }, z.core.$strict>>;
        stateSchemaRef: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            path: z.ZodString;
            contentHash: z.ZodString;
            sizeBytes: z.ZodNumber;
            mediaType: z.ZodString;
            visibility: z.ZodEnum<{
                host_private: "host_private";
                policy: "policy";
                verifier: "verifier";
            }>;
        }, z.core.$strict>>;
        artifactCollection: z.ZodObject<{
            maxArtifacts: z.ZodNumber;
            maxTotalBytes: z.ZodNumber;
        }, z.core.$strict>;
        adapterConformanceHashes: z.ZodRecord<z.ZodString, z.ZodString>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    verifierSet: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.verifierSetRelease.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodEnum<{
                artifact: "artifact";
                content: "content";
                runtime_event: "runtime_event";
                schema: "schema";
                state: "state";
            }>;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"model_judge">;
            rubricRef: z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>;
            calibrationStatus: z.ZodEnum<{
                failed: "failed";
                passed: "passed";
                pending: "pending";
            }>;
            model: z.ZodOptional<z.ZodObject<{
                providerId: z.ZodString;
                modelId: z.ZodString;
                revision: z.ZodNullable<z.ZodString>;
            }, z.core.$strict>>;
            temperature: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"custom_verifier">;
            runtime: z.ZodOptional<z.ZodEnum<{
                isolated_javascript: "isolated_javascript";
                sandbox_process: "sandbox_process";
            }>>;
            verifierRef: z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>;
            exportName: z.ZodOptional<z.ZodString>;
            timeoutMs: z.ZodNumber;
            networkPolicy: z.ZodLiteral<"none">;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
            version: z.ZodString;
            weight: z.ZodDefault<z.ZodNumber>;
            hardGate: z.ZodDefault<z.ZodBoolean>;
            rewardEligible: z.ZodDefault<z.ZodBoolean>;
            privileged: z.ZodDefault<z.ZodBoolean>;
            kind: z.ZodLiteral<"human">;
            rubricRef: z.ZodObject<{
                id: z.ZodString;
                path: z.ZodString;
                contentHash: z.ZodString;
                sizeBytes: z.ZodNumber;
                mediaType: z.ZodString;
                visibility: z.ZodEnum<{
                    host_private: "host_private";
                    policy: "policy";
                    verifier: "verifier";
                }>;
            }, z.core.$strict>;
            reviewerRole: z.ZodString;
            form: z.ZodOptional<z.ZodObject<{
                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                mode: z.ZodEnum<{
                    individual: "individual";
                    pairwise: "pairwise";
                }>;
                instructions: z.ZodString;
                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"score">;
                    minimum: z.ZodNumber;
                    maximum: z.ZodNumber;
                    step: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"category">;
                    options: z.ZodArray<z.ZodString>;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"boolean">;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"text">;
                    minimumLength: z.ZodOptional<z.ZodNumber>;
                    maximumLength: z.ZodNumber;
                }, z.core.$strict>, z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    instructions: z.ZodString;
                    required: z.ZodBoolean;
                    allowAbstain: z.ZodBoolean;
                    requireRationale: z.ZodOptional<z.ZodBoolean>;
                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
                        description: z.ZodString;
                    }, z.core.$strict>>>;
                    kind: z.ZodLiteral<"preference">;
                    requireStrength: z.ZodOptional<z.ZodBoolean>;
                    allowTie: z.ZodBoolean;
                }, z.core.$strict>], "kind">>;
            }, z.core.$strict>>;
        }, z.core.$strict>]>>;
        isolation: z.ZodObject<{
            processBoundary: z.ZodEnum<{
                container: "container";
                isolated_process: "isolated_process";
                same_process: "same_process";
            }>;
            networkPolicy: z.ZodLiteral<"none">;
            defaultTimeoutMs: z.ZodNumber;
        }, z.core.$strict>;
        calibrationReceiptRefs: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            contentHash: z.ZodString;
        }, z.core.$strict>>;
        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
    javascript: z.ZodObject<{
        schemaVersion: z.ZodLiteral<"openpond.javascriptEnvironment.v1">;
        id: z.ZodString;
        revision: z.ZodNumber;
        module: z.ZodObject<{
            id: z.ZodString;
            path: z.ZodString;
            contentHash: z.ZodString;
            sizeBytes: z.ZodNumber;
            mediaType: z.ZodString;
            visibility: z.ZodEnum<{
                host_private: "host_private";
                policy: "policy";
                verifier: "verifier";
            }>;
        }, z.core.$strict>;
        tools: z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            description: z.ZodString;
            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            inputSchemaHash: z.ZodString;
            sideEffect: z.ZodEnum<{
                read: "read";
                write: "write";
            }>;
            timeoutMs: z.ZodNumber;
        }, z.core.$strict>>;
        maxSteps: z.ZodNumber;
        maxStateBytes: z.ZodNumber;
        maxObservationBytes: z.ZodNumber;
        operationTimeoutMs: z.ZodNumber;
        executionServices: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            id: z.ZodString;
            operation: z.ZodEnum<{
                collect: "collect";
                step: "step";
            }>;
            toolName: z.ZodOptional<z.ZodString>;
            timeoutMs: z.ZodNumber;
            kind: z.ZodLiteral<"sqlite.v1">;
            sql: z.ZodObject<{
                scope: z.ZodEnum<{
                    arguments: "arguments";
                    initialState: "initialState";
                    input: "input";
                    state: "state";
                }>;
                path: z.ZodArray<z.ZodString>;
            }, z.core.$strict>;
            snapshot: z.ZodObject<{
                scope: z.ZodEnum<{
                    arguments: "arguments";
                    initialState: "initialState";
                    input: "input";
                    state: "state";
                }>;
                path: z.ZodArray<z.ZodString>;
            }, z.core.$strict>;
            maxRows: z.ZodNumber;
            maxResultBytes: z.ZodNumber;
        }, z.core.$strict>, z.ZodObject<{
            id: z.ZodString;
            operation: z.ZodEnum<{
                collect: "collect";
                step: "step";
            }>;
            toolName: z.ZodOptional<z.ZodString>;
            timeoutMs: z.ZodNumber;
            kind: z.ZodLiteral<"javascript.v1">;
            source: z.ZodObject<{
                scope: z.ZodEnum<{
                    arguments: "arguments";
                    initialState: "initialState";
                    input: "input";
                    state: "state";
                }>;
                path: z.ZodArray<z.ZodString>;
            }, z.core.$strict>;
            cases: z.ZodObject<{
                scope: z.ZodEnum<{
                    arguments: "arguments";
                    initialState: "initialState";
                    input: "input";
                    state: "state";
                }>;
                path: z.ZodArray<z.ZodString>;
            }, z.core.$strict>;
            exportName: z.ZodString;
            maxCases: z.ZodNumber;
            maxResultBytes: z.ZodNumber;
        }, z.core.$strict>], "kind">>>;
        contentHash: z.ZodString;
    }, z.core.$strict>;
}, z.core.$strict>;
export type ModelStarterExecution = z.infer<typeof ModelStarterExecutionSchema>;
export declare const ModelStarterToolFixtureScriptSchema: z.ZodObject<{
    actions: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type ModelStarterExecutionContext = Pick<TasksetRelease, "environment" | "environmentRelease" | "verifierSetRelease" | "tools" | "capabilities" | "policy" | "graders" | "tasks">;
/** Derivable from immutable Taskset refs, without putting private code in its metadata. */
export declare function modelStarterExecutionAssetId(context: Pick<ModelStarterExecutionContext, "environmentRelease" | "verifierSetRelease">): string;
/** Persist alongside the package's private assets in the same creation transaction.
 * The existing authored-text resource bound also applies to this small closure. */
export declare function createModelStarterExecutionAsset(value: ModelStarterExecution): LearningTextAsset;
/** The caller owns and verifies the Taskset manifest; this verifies its private
 * resource graph. Passing selected immutable task rows permits bounded hydration. */
export declare function resolveModelStarterExecutionAsset(context: ModelStarterExecutionContext, asset: LearningTextAsset, assets: LearningTextAsset[]): ModelStarterExecution;
/** Close executable dependencies before a host persists or runs a package. */
export declare function validateModelStarterExecution(execution: ModelStarterExecution | undefined, taskset: ModelStarterExecutionContext, assets: LearningTextAsset[]): void;
//# sourceMappingURL=model-starter-execution.d.ts.map