import { z } from "zod";
import { ExperimentListQuerySchema } from "./experiment-contracts.js";
import { RunExperimentSchema } from "./experiment-run-contracts.js";
import { PrepareHarnessExperimentSchema } from "./experiment-contracts.js";
import { type ExperimentScoringRequest } from "./experiment-scoring-contracts.js";
export declare class OpenPondExperimentError extends Error {
    readonly status: number;
    readonly code: string;
    constructor(status: number, code: string, message: string);
}
/** One Experiment is one run with its immutable configuration and results. */
export declare class OpenPondExperimentsClient {
    private readonly options;
    private readonly baseUrl;
    constructor(options: {
        baseUrl: string;
        apiKey: string;
        teamId: string;
        fetch?: typeof fetch;
    });
    defaults(signal?: AbortSignal): Promise<{
        maximumSpendUsd: number;
        maximumComparisonSpendUsd: number;
        initialOutputTokens: number;
    }>;
    createComparisonBudget(value: {
        id: string;
        operationIds: string[];
        maximumSpendUsd?: number;
    }, signal?: AbortSignal): Promise<{
        id: string;
        teamId: string;
        maximumSpendUsd: number;
        settledUsd: number;
        reservedUsd: number;
        remainingUsd: number;
        operations: {
            operationId: string;
            runId: string | null;
        }[];
    }>;
    comparisonBudget(id: string, signal?: AbortSignal): Promise<{
        id: string;
        teamId: string;
        maximumSpendUsd: number;
        settledUsd: number;
        reservedUsd: number;
        remainingUsd: number;
        operations: {
            operationId: string;
            runId: string | null;
        }[];
    }>;
    private comparisonBudgetResult;
    /** Discover released workspace Harnesses independently of Project targets. */
    harnessSources(options?: {
        cursor?: string;
        signal?: AbortSignal;
    }): Promise<{
        teamId: string;
        items: {
            name: string;
            source: {
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                agentSnapshot: {
                    id: string;
                    contentHash: string;
                };
                sourcePackageHash: string;
            };
            ready: boolean;
            reason: string | null;
        }[];
        nextCursor: string | null;
    }>;
    /** Resolves a released target without saving a definition or dispatching it. */
    prepareHarness(value: Omit<z.input<typeof PrepareHarnessExperimentSchema>, "maximumCostUsd"> & {
        maximumCostUsd?: number;
    }, signal?: AbortSignal): Promise<{
        request: {
            schemaVersion: "openpond.modelTasksetRunRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policy: {
                kind: "hosted_harness";
                modelId: string;
                maxOutputTokens?: number | undefined;
                temperature?: number | undefined;
                topP?: number | undefined;
                localRuntime?: {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
                reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                profileRepositoryId: string;
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                modelConfigurationHash: string;
                packageHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
            } | {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
        };
        manifest: {
            schemaVersion: "openpond.tasksetRunManifest.v1";
            id: string;
            tasksetRelease: {
                id: string;
                contentHash: string;
            };
            packageHash: string;
            execution: {
                kind: "taskset";
                environmentRelease: {
                    id: string;
                    contentHash: string;
                };
                verifierSetRelease: {
                    id: string;
                    contentHash: string;
                };
                policyHash: string;
            } | {
                kind: "harness";
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
            };
            profileEvaluation?: {
                profileId: string;
                sourceRevision: string;
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                catalogHash: string;
                definitionId: string;
                definitionHash: string;
                target: {
                    kind: "profile";
                } | {
                    kind: "workflow";
                    workflowId: string;
                } | {
                    kind: "skill";
                    skillPath: string;
                } | {
                    kind: "agent_action";
                    actionId: string;
                };
                environmentHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
            } | undefined;
            policy: {
                kind: "model";
                model: {
                    provider: string;
                    model: string;
                    revision: string | null;
                    artifactHash: string | null;
                    tokenizerRevision: string | null;
                    chatTemplateHash: string | null;
                };
                configurationHash: string;
            } | {
                kind: "fixture";
            };
            gradingRole: "evaluation";
            metricPolicy: {
                schemaVersion: "openpond.tasksetMetricPolicy.v1";
                primaryMetric: string;
                aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                missingReward: "exclude" | "zero";
                taskWeights?: Record<string, number> | undefined;
                customAggregator: {
                    module: string;
                    exportName: string;
                    contentHash: string;
                    timeoutMs: number;
                    networkPolicy: "none";
                } | null;
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
            runtimeTarget: {
                adapterId: string;
                placement: "colocated" | "local" | "provider_native" | "remote";
                runtimeVersion: string;
                capabilityReceipt: string;
            };
            limits: {
                maxTurns: number;
                timeoutMs: number;
                maxOutputBytes: number;
                maximumSpendUsd: number | null;
            };
            createdAt: string;
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        maximumCostUsd: number;
        graders: {
            id: string;
            version: string;
            contentHash: string;
            name?: string | undefined;
            feedbackKey: string;
            release: {
                id: string;
                revision: number;
                contentHash: string;
            } | null;
            mappings?: {
                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                path: string[];
                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                sourcePath: string[];
            }[] | undefined;
        }[];
    }>;
    run(value: Omit<z.input<typeof RunExperimentSchema>, "maximumCostUsd"> & {
        maximumCostUsd?: number;
    }, signal?: AbortSignal): Promise<{
        summary: {
            schemaVersion: "openpond.modelTasksetRunSummary.v1";
            id: string;
            revision: number;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            operationId: string;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policyKind: "fixture" | "hosted_chat" | "hosted_harness";
            manifestHash: string;
            status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
            totalCount: number;
            counts: {
                pending: number;
                running: number;
                completed: number;
                failed: number;
                cancelled: number;
            };
            createdAt: string;
            startedAt: string | null;
            completedAt: string | null;
            cleanupComplete: boolean;
            resultAvailable: boolean;
            score: number | null;
            metricName: string;
            error: {
                code: string;
                message: string;
            } | null;
        };
        request: {
            schemaVersion: "openpond.modelTasksetRunRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policy: {
                kind: "hosted_harness";
                modelId: string;
                maxOutputTokens?: number | undefined;
                temperature?: number | undefined;
                topP?: number | undefined;
                localRuntime?: {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
                reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                profileRepositoryId: string;
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                modelConfigurationHash: string;
                packageHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
            } | {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
        };
        manifest: {
            schemaVersion: "openpond.tasksetRunManifest.v1";
            id: string;
            tasksetRelease: {
                id: string;
                contentHash: string;
            };
            packageHash: string;
            execution: {
                kind: "taskset";
                environmentRelease: {
                    id: string;
                    contentHash: string;
                };
                verifierSetRelease: {
                    id: string;
                    contentHash: string;
                };
                policyHash: string;
            } | {
                kind: "harness";
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
            };
            profileEvaluation?: {
                profileId: string;
                sourceRevision: string;
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                catalogHash: string;
                definitionId: string;
                definitionHash: string;
                target: {
                    kind: "profile";
                } | {
                    kind: "workflow";
                    workflowId: string;
                } | {
                    kind: "skill";
                    skillPath: string;
                } | {
                    kind: "agent_action";
                    actionId: string;
                };
                environmentHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
            } | undefined;
            policy: {
                kind: "model";
                model: {
                    provider: string;
                    model: string;
                    revision: string | null;
                    artifactHash: string | null;
                    tokenizerRevision: string | null;
                    chatTemplateHash: string | null;
                };
                configurationHash: string;
            } | {
                kind: "fixture";
            };
            gradingRole: "evaluation";
            metricPolicy: {
                schemaVersion: "openpond.tasksetMetricPolicy.v1";
                primaryMetric: string;
                aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                missingReward: "exclude" | "zero";
                taskWeights?: Record<string, number> | undefined;
                customAggregator: {
                    module: string;
                    exportName: string;
                    contentHash: string;
                    timeoutMs: number;
                    networkPolicy: "none";
                } | null;
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
            runtimeTarget: {
                adapterId: string;
                placement: "colocated" | "local" | "provider_native" | "remote";
                runtimeVersion: string;
                capabilityReceipt: string;
            };
            limits: {
                maxTurns: number;
                timeoutMs: number;
                maxOutputBytes: number;
                maximumSpendUsd: number | null;
            };
            createdAt: string;
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        policySnapshot: {
            modelId: string;
            provider: string;
            upstreamModelId: string;
            configurationHash: string;
        } | null;
        configuration: {
            request: {
                schemaVersion: "openpond.modelTasksetRunRequest.v1";
                operationId: string;
                teamId: string;
                modelProjectId: string | null;
                name?: string | undefined;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                policy: {
                    kind: "hosted_harness";
                    modelId: string;
                    maxOutputTokens?: number | undefined;
                    temperature?: number | undefined;
                    topP?: number | undefined;
                    localRuntime?: {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                    reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                    profileRepositoryId: string;
                    source: {
                        profileId: string;
                        sourceRevision: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        catalogHash: string;
                        definitionId: string;
                        definitionHash: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        environmentHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                    };
                    modelConfigurationHash: string;
                    packageHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                } | {
                    kind: "hosted_chat";
                    modelId: string;
                    localRuntime?: {
                        providerId: "claude-code";
                        configurationHash: string;
                        executableHash: string;
                        version: string;
                        capabilityHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                        maximumTurns: number;
                        holdOpen: boolean;
                    } | {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | {
                        providerId: "custom-openai-compatible";
                        configurationHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    harness?: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    } | undefined;
                    messages?: {
                        role: "assistant" | "system" | "user";
                        content: string;
                    }[] | undefined;
                    maxOutputTokens: number;
                    temperature: number;
                    topP: number;
                } | {
                    kind: "fixture";
                };
                population: {
                    receiptId: string;
                    taskId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
            };
            maximumCostUsd: number;
            graders: {
                id: string;
                version: string;
                contentHash: string;
                name?: string | undefined;
                feedbackKey: string;
                release: {
                    id: string;
                    revision: number;
                    contentHash: string;
                } | null;
                mappings?: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[] | undefined;
            }[];
            admissionRequestHash?: string | undefined;
            sourceExperimentId?: string | undefined;
            configurationHash: string;
        };
    }>;
    get(id: string, options?: {
        signal?: AbortSignal;
    }): Promise<{
        summary: {
            schemaVersion: "openpond.modelTasksetRunSummary.v1";
            id: string;
            revision: number;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            operationId: string;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policyKind: "fixture" | "hosted_chat" | "hosted_harness";
            manifestHash: string;
            status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
            totalCount: number;
            counts: {
                pending: number;
                running: number;
                completed: number;
                failed: number;
                cancelled: number;
            };
            createdAt: string;
            startedAt: string | null;
            completedAt: string | null;
            cleanupComplete: boolean;
            resultAvailable: boolean;
            score: number | null;
            metricName: string;
            error: {
                code: string;
                message: string;
            } | null;
        };
        request: {
            schemaVersion: "openpond.modelTasksetRunRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policy: {
                kind: "hosted_harness";
                modelId: string;
                maxOutputTokens?: number | undefined;
                temperature?: number | undefined;
                topP?: number | undefined;
                localRuntime?: {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
                reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                profileRepositoryId: string;
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                modelConfigurationHash: string;
                packageHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
            } | {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
        };
        manifest: {
            schemaVersion: "openpond.tasksetRunManifest.v1";
            id: string;
            tasksetRelease: {
                id: string;
                contentHash: string;
            };
            packageHash: string;
            execution: {
                kind: "taskset";
                environmentRelease: {
                    id: string;
                    contentHash: string;
                };
                verifierSetRelease: {
                    id: string;
                    contentHash: string;
                };
                policyHash: string;
            } | {
                kind: "harness";
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
            };
            profileEvaluation?: {
                profileId: string;
                sourceRevision: string;
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                catalogHash: string;
                definitionId: string;
                definitionHash: string;
                target: {
                    kind: "profile";
                } | {
                    kind: "workflow";
                    workflowId: string;
                } | {
                    kind: "skill";
                    skillPath: string;
                } | {
                    kind: "agent_action";
                    actionId: string;
                };
                environmentHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
            } | undefined;
            policy: {
                kind: "model";
                model: {
                    provider: string;
                    model: string;
                    revision: string | null;
                    artifactHash: string | null;
                    tokenizerRevision: string | null;
                    chatTemplateHash: string | null;
                };
                configurationHash: string;
            } | {
                kind: "fixture";
            };
            gradingRole: "evaluation";
            metricPolicy: {
                schemaVersion: "openpond.tasksetMetricPolicy.v1";
                primaryMetric: string;
                aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                missingReward: "exclude" | "zero";
                taskWeights?: Record<string, number> | undefined;
                customAggregator: {
                    module: string;
                    exportName: string;
                    contentHash: string;
                    timeoutMs: number;
                    networkPolicy: "none";
                } | null;
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
            runtimeTarget: {
                adapterId: string;
                placement: "colocated" | "local" | "provider_native" | "remote";
                runtimeVersion: string;
                capabilityReceipt: string;
            };
            limits: {
                maxTurns: number;
                timeoutMs: number;
                maxOutputBytes: number;
                maximumSpendUsd: number | null;
            };
            createdAt: string;
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        policySnapshot: {
            modelId: string;
            provider: string;
            upstreamModelId: string;
            configurationHash: string;
        } | null;
        configuration: {
            request: {
                schemaVersion: "openpond.modelTasksetRunRequest.v1";
                operationId: string;
                teamId: string;
                modelProjectId: string | null;
                name?: string | undefined;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                policy: {
                    kind: "hosted_harness";
                    modelId: string;
                    maxOutputTokens?: number | undefined;
                    temperature?: number | undefined;
                    topP?: number | undefined;
                    localRuntime?: {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                    reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                    profileRepositoryId: string;
                    source: {
                        profileId: string;
                        sourceRevision: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        catalogHash: string;
                        definitionId: string;
                        definitionHash: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        environmentHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                    };
                    modelConfigurationHash: string;
                    packageHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                } | {
                    kind: "hosted_chat";
                    modelId: string;
                    localRuntime?: {
                        providerId: "claude-code";
                        configurationHash: string;
                        executableHash: string;
                        version: string;
                        capabilityHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                        maximumTurns: number;
                        holdOpen: boolean;
                    } | {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | {
                        providerId: "custom-openai-compatible";
                        configurationHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    harness?: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    } | undefined;
                    messages?: {
                        role: "assistant" | "system" | "user";
                        content: string;
                    }[] | undefined;
                    maxOutputTokens: number;
                    temperature: number;
                    topP: number;
                } | {
                    kind: "fixture";
                };
                population: {
                    receiptId: string;
                    taskId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
            };
            maximumCostUsd: number;
            graders: {
                id: string;
                version: string;
                contentHash: string;
                name?: string | undefined;
                feedbackKey: string;
                release: {
                    id: string;
                    revision: number;
                    contentHash: string;
                } | null;
                mappings?: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[] | undefined;
            }[];
            admissionRequestHash?: string | undefined;
            sourceExperimentId?: string | undefined;
            configurationHash: string;
        };
    }>;
    diagnostics(id: string, options?: {
        afterSequence?: number;
        afterCallId?: string;
        manifestHash?: string;
        signal?: AbortSignal;
    }): Promise<{
        schemaVersion: "openpond.runDiagnostics.v1";
        teamId: string;
        runId: string;
        location: "hosted" | "local";
        manifestHash: string;
        observedAt: string;
        status: string;
        startedAt: string | null;
        completedAt: string | null;
        error: string | null;
        resultAvailable: boolean;
        parent: {
            id: string;
            status: string;
            attempt: number | null;
            heartbeatAt: string | null;
            leaseExpiresAt: string | null;
            releasedAt: string | null;
            errorCode: string | null;
        } | null;
        accounting: {
            maximumUsd: number | null;
            settledUsd: number | null;
            outstandingUsd: number | null;
            outstandingCount: number | null;
            final: boolean;
            receiptCount: number | null;
        };
        events: {
            id: string;
            sequence: number;
            at: string | null;
            type: string;
            action: string | null;
            correlationId: string | null;
            attempt: number | null;
            taskId: string | null;
            status: string | null;
            errorCode: string | null;
            cleanupComplete: boolean | null;
        }[];
        nextEventCursor: number | null;
        eventCount: number;
        calls: {
            id: string;
            kind: string;
            status: string;
            receiptId: string | null;
            maximumUsd: number | null;
            settledUsd: number | null;
            model: string | null;
            durationMs: number | null;
            inputTokens: number | null;
            outputTokens: number | null;
            totalTokens: number | null;
        }[];
        nextCallCursor: string | null;
        callCount: number;
        limitations: string[];
        contentHash: string;
    }>;
    list(value?: z.input<typeof ExperimentListQuerySchema>, signal?: AbortSignal): Promise<{
        items: {
            summary: {
                schemaVersion: "openpond.modelTasksetRunSummary.v1";
                id: string;
                revision: number;
                teamId: string;
                modelProjectId: string | null;
                name?: string | undefined;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                operationId: string;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                policyKind: "fixture" | "hosted_chat" | "hosted_harness";
                manifestHash: string;
                status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
                totalCount: number;
                counts: {
                    pending: number;
                    running: number;
                    completed: number;
                    failed: number;
                    cancelled: number;
                };
                createdAt: string;
                startedAt: string | null;
                completedAt: string | null;
                cleanupComplete: boolean;
                resultAvailable: boolean;
                score: number | null;
                metricName: string;
                error: {
                    code: string;
                    message: string;
                } | null;
            };
            request: {
                schemaVersion: "openpond.modelTasksetRunRequest.v1";
                operationId: string;
                teamId: string;
                modelProjectId: string | null;
                name?: string | undefined;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                policy: {
                    kind: "hosted_harness";
                    modelId: string;
                    maxOutputTokens?: number | undefined;
                    temperature?: number | undefined;
                    topP?: number | undefined;
                    localRuntime?: {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                    reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                    profileRepositoryId: string;
                    source: {
                        profileId: string;
                        sourceRevision: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        catalogHash: string;
                        definitionId: string;
                        definitionHash: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        environmentHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                    };
                    modelConfigurationHash: string;
                    packageHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                } | {
                    kind: "hosted_chat";
                    modelId: string;
                    localRuntime?: {
                        providerId: "claude-code";
                        configurationHash: string;
                        executableHash: string;
                        version: string;
                        capabilityHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                        maximumTurns: number;
                        holdOpen: boolean;
                    } | {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | {
                        providerId: "custom-openai-compatible";
                        configurationHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    harness?: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    } | undefined;
                    messages?: {
                        role: "assistant" | "system" | "user";
                        content: string;
                    }[] | undefined;
                    maxOutputTokens: number;
                    temperature: number;
                    topP: number;
                } | {
                    kind: "fixture";
                };
                population: {
                    receiptId: string;
                    taskId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
            };
            manifest: {
                schemaVersion: "openpond.tasksetRunManifest.v1";
                id: string;
                tasksetRelease: {
                    id: string;
                    contentHash: string;
                };
                packageHash: string;
                execution: {
                    kind: "taskset";
                    environmentRelease: {
                        id: string;
                        contentHash: string;
                    };
                    verifierSetRelease: {
                        id: string;
                        contentHash: string;
                    };
                    policyHash: string;
                } | {
                    kind: "harness";
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                };
                profileEvaluation?: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                } | undefined;
                policy: {
                    kind: "model";
                    model: {
                        provider: string;
                        model: string;
                        revision: string | null;
                        artifactHash: string | null;
                        tokenizerRevision: string | null;
                        chatTemplateHash: string | null;
                    };
                    configurationHash: string;
                } | {
                    kind: "fixture";
                };
                gradingRole: "evaluation";
                metricPolicy: {
                    schemaVersion: "openpond.tasksetMetricPolicy.v1";
                    primaryMetric: string;
                    aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                    missingReward: "exclude" | "zero";
                    taskWeights?: Record<string, number> | undefined;
                    customAggregator: {
                        module: string;
                        exportName: string;
                        contentHash: string;
                        timeoutMs: number;
                        networkPolicy: "none";
                    } | null;
                };
                population: {
                    receiptId: string;
                    taskId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
                runtimeTarget: {
                    adapterId: string;
                    placement: "colocated" | "local" | "provider_native" | "remote";
                    runtimeVersion: string;
                    capabilityReceipt: string;
                };
                limits: {
                    maxTurns: number;
                    timeoutMs: number;
                    maxOutputBytes: number;
                    maximumSpendUsd: number | null;
                };
                createdAt: string;
                metadata: Record<string, unknown>;
                contentHash: string;
            };
            policySnapshot: {
                modelId: string;
                provider: string;
                upstreamModelId: string;
                configurationHash: string;
            } | null;
            configuration: {
                request: {
                    schemaVersion: "openpond.modelTasksetRunRequest.v1";
                    operationId: string;
                    teamId: string;
                    modelProjectId: string | null;
                    name?: string | undefined;
                    project?: {
                        id: string;
                        revision: number;
                        contentHash: string;
                        targetId: string | null;
                    } | undefined;
                    taskset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    policy: {
                        kind: "hosted_harness";
                        modelId: string;
                        maxOutputTokens?: number | undefined;
                        temperature?: number | undefined;
                        topP?: number | undefined;
                        localRuntime?: {
                            providerId: "codex";
                            configurationHash: string;
                            accountHash: string;
                            reasoningEffort: "high" | "low" | "medium" | "xhigh";
                            maximumRequestCostUsd: number;
                            requestTimeoutMs: number;
                        } | undefined;
                        candidate?: {
                            artifactId: string;
                            contentHash: string;
                            preparationId: string;
                            dispatchId: string;
                            baseProfileId: string;
                            workerImageDigest: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                        reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                        profileRepositoryId: string;
                        source: {
                            profileId: string;
                            sourceRevision: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            catalogHash: string;
                            definitionId: string;
                            definitionHash: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            environmentHash: string;
                            externalDatasetBinding?: {
                                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                                dataset: {
                                    id: string;
                                    contentHash: string;
                                    revision: number;
                                };
                                packageHash: string;
                                profileId: string;
                                target: {
                                    kind: "profile";
                                } | {
                                    kind: "workflow";
                                    workflowId: string;
                                } | {
                                    kind: "skill";
                                    skillPath: string;
                                } | {
                                    kind: "agent_action";
                                    actionId: string;
                                };
                                declaredProfileCatalogHash: string | null;
                                protectedProfileClosureHash: string;
                                recordedOrigin?: {
                                    execution: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    originalEvidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    members: {
                                        caseId: string;
                                        seed: string;
                                        fixtureId: string;
                                        sourceId: string;
                                        snapshotHash: string;
                                        boundaryRevisionHash: string;
                                    }[];
                                } | undefined;
                                gradingSource?: {
                                    pass: {
                                        id: string;
                                        contentHash: string;
                                    };
                                    evidence: {
                                        id: string;
                                        contentHash: string;
                                    };
                                } | undefined;
                                split: "frozen_eval" | "test" | "train" | "validation";
                                population: {
                                    taskId: string;
                                    seed: string;
                                    fixtureId: string | null;
                                }[];
                                evaluators: {
                                    release: {
                                        id: string;
                                        contentHash: string;
                                        revision: string | number;
                                    };
                                    feedbackKey: string;
                                    configurationHash: string;
                                    output: "boolean" | "category" | "score";
                                    categories: string[];
                                }[];
                                fieldMappingsHash: string;
                                fieldMappings: {
                                    graderId: string;
                                    fields: {
                                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        path: string[];
                                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                        sourcePath: string[];
                                    }[];
                                }[];
                                environmentHash: string;
                                privateDatasetClosureHash: string;
                                criterion: {
                                    minimumPassRate: number;
                                    requireComplete: boolean;
                                };
                                contentHash: string;
                            } | undefined;
                            sourceCandidate?: {
                                candidateId: string;
                                frozenRevision: number;
                                frozenHash: string;
                                harnessRelease: {
                                    id: string;
                                    contentHash: string;
                                };
                                protectedClosureHash: string;
                            } | undefined;
                        };
                        modelConfigurationHash: string;
                        packageHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                    } | {
                        kind: "hosted_chat";
                        modelId: string;
                        localRuntime?: {
                            providerId: "claude-code";
                            configurationHash: string;
                            executableHash: string;
                            version: string;
                            capabilityHash: string;
                            maximumRequestCostUsd: number;
                            requestTimeoutMs: number;
                            maximumTurns: number;
                            holdOpen: boolean;
                        } | {
                            providerId: "codex";
                            configurationHash: string;
                            accountHash: string;
                            reasoningEffort: "high" | "low" | "medium" | "xhigh";
                            maximumRequestCostUsd: number;
                            requestTimeoutMs: number;
                        } | {
                            providerId: "custom-openai-compatible";
                            configurationHash: string;
                            maximumRequestCostUsd: number;
                            requestTimeoutMs: number;
                        } | undefined;
                        candidate?: {
                            artifactId: string;
                            contentHash: string;
                            preparationId: string;
                            dispatchId: string;
                            baseProfileId: string;
                            workerImageDigest: string;
                        } | undefined;
                        harness?: {
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            agentSnapshot: {
                                id: string;
                                contentHash: string;
                            };
                            sourcePackageHash: string;
                        } | undefined;
                        messages?: {
                            role: "assistant" | "system" | "user";
                            content: string;
                        }[] | undefined;
                        maxOutputTokens: number;
                        temperature: number;
                        topP: number;
                    } | {
                        kind: "fixture";
                    };
                    population: {
                        receiptId: string;
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                };
                maximumCostUsd: number;
                graders: {
                    id: string;
                    version: string;
                    contentHash: string;
                    name?: string | undefined;
                    feedbackKey: string;
                    release: {
                        id: string;
                        revision: number;
                        contentHash: string;
                    } | null;
                    mappings?: {
                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                        path: string[];
                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                        sourcePath: string[];
                    }[] | undefined;
                }[];
                admissionRequestHash?: string | undefined;
                sourceExperimentId?: string | undefined;
                configurationHash: string;
            };
        }[];
        nextCursor: string | null;
    }>;
    result(executionId: string, signal?: AbortSignal): Promise<{
        manifest: {
            schemaVersion: "openpond.experimentManifest.v1";
            id: string;
            name: string;
            teamId: string;
            operationId: string;
            maximumCostUsd: number | null;
            dataset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            target: {
                kind: "model";
                modelId: string;
                configurationHash: string;
            } | {
                kind: "harness";
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                model: {
                    modelId: string;
                    configurationHash: string;
                };
            } | {
                kind: "agent";
                source: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                };
                model: {
                    modelId: string;
                    configurationHash: string;
                };
            } | {
                kind: "fixture";
                configurationHash: string;
            };
            execution?: {
                packageHash: string;
                runtimeTargetHash: string;
                metricPolicyHash: string;
                compatibility?: {
                    protocol: "openpond.evaluation-execution.v1";
                    targetKind: "agent" | "fixture" | "harness" | "model";
                } | undefined;
            } | undefined;
            lineage?: {
                definition: {
                    id: string;
                    contentHash: string;
                    revision: number;
                } | null;
                execution: {
                    id: string;
                    contentHash: string;
                };
                scoringPassId: string | null;
                humanProjection?: {
                    originalManifest: {
                        id: string;
                        contentHash: string;
                    };
                    selectionHash: string;
                    rulesHash: string;
                } | undefined;
            } | undefined;
            evaluators: {
                release: {
                    id: string;
                    contentHash: string;
                    revision: string | number;
                };
                feedbackKey: string;
                configurationHash?: string | undefined;
                output: "boolean" | "category" | "score";
                categories: string[];
            }[];
            population: {
                caseId: string;
                seed: string;
                fixtureId: string | null;
            }[];
            createdAt: string;
            contentHash: string;
        };
        result: {
            schemaVersion: "openpond.experimentResult.v1";
            manifest: {
                id: string;
                contentHash: string;
            };
            status: "cancelled" | "completed" | "failed";
            cases: {
                identity: {
                    caseId: string;
                    seed: string;
                    fixtureId: string | null;
                };
                status: "cancelled" | "completed" | "failed" | "unavailable";
                output: unknown;
                error: {
                    code: string;
                    message: string;
                } | null;
                feedback: {
                    feedbackKey: string;
                    evaluator: {
                        id: string;
                        contentHash: string;
                        revision: string | number;
                    };
                    status: "failed" | "pending" | "scored" | "unavailable";
                    value: string | number | boolean | null;
                    passed?: boolean | null | undefined;
                    reasoning: string | null;
                    evidenceRefs: {
                        id: string;
                        contentHash: string;
                        mediaType: string | null;
                        sizeBytes: number | null;
                    }[];
                }[];
                usage: {
                    inputTokens: number | null;
                    outputTokens: number | null;
                    totalTokens: number | null;
                    costUsd: number | null;
                    latencyMs: number | null;
                };
                traceRef: {
                    id: string;
                    contentHash: string;
                    mediaType: string | null;
                    sizeBytes: number | null;
                } | null;
                startedAt: string | null;
                completedAt: string | null;
            }[];
            completedAt: string;
            contentHash: string;
        };
        executionId: string;
        passId: string | null;
    }>;
    cancel(id: string, signal?: AbortSignal): Promise<{
        summary: {
            schemaVersion: "openpond.modelTasksetRunSummary.v1";
            id: string;
            revision: number;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            operationId: string;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policyKind: "fixture" | "hosted_chat" | "hosted_harness";
            manifestHash: string;
            status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
            totalCount: number;
            counts: {
                pending: number;
                running: number;
                completed: number;
                failed: number;
                cancelled: number;
            };
            createdAt: string;
            startedAt: string | null;
            completedAt: string | null;
            cleanupComplete: boolean;
            resultAvailable: boolean;
            score: number | null;
            metricName: string;
            error: {
                code: string;
                message: string;
            } | null;
        };
        request: {
            schemaVersion: "openpond.modelTasksetRunRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policy: {
                kind: "hosted_harness";
                modelId: string;
                maxOutputTokens?: number | undefined;
                temperature?: number | undefined;
                topP?: number | undefined;
                localRuntime?: {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
                reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                profileRepositoryId: string;
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                modelConfigurationHash: string;
                packageHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
            } | {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
        };
        manifest: {
            schemaVersion: "openpond.tasksetRunManifest.v1";
            id: string;
            tasksetRelease: {
                id: string;
                contentHash: string;
            };
            packageHash: string;
            execution: {
                kind: "taskset";
                environmentRelease: {
                    id: string;
                    contentHash: string;
                };
                verifierSetRelease: {
                    id: string;
                    contentHash: string;
                };
                policyHash: string;
            } | {
                kind: "harness";
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
            };
            profileEvaluation?: {
                profileId: string;
                sourceRevision: string;
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                catalogHash: string;
                definitionId: string;
                definitionHash: string;
                target: {
                    kind: "profile";
                } | {
                    kind: "workflow";
                    workflowId: string;
                } | {
                    kind: "skill";
                    skillPath: string;
                } | {
                    kind: "agent_action";
                    actionId: string;
                };
                environmentHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
            } | undefined;
            policy: {
                kind: "model";
                model: {
                    provider: string;
                    model: string;
                    revision: string | null;
                    artifactHash: string | null;
                    tokenizerRevision: string | null;
                    chatTemplateHash: string | null;
                };
                configurationHash: string;
            } | {
                kind: "fixture";
            };
            gradingRole: "evaluation";
            metricPolicy: {
                schemaVersion: "openpond.tasksetMetricPolicy.v1";
                primaryMetric: string;
                aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                missingReward: "exclude" | "zero";
                taskWeights?: Record<string, number> | undefined;
                customAggregator: {
                    module: string;
                    exportName: string;
                    contentHash: string;
                    timeoutMs: number;
                    networkPolicy: "none";
                } | null;
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
            runtimeTarget: {
                adapterId: string;
                placement: "colocated" | "local" | "provider_native" | "remote";
                runtimeVersion: string;
                capabilityReceipt: string;
            };
            limits: {
                maxTurns: number;
                timeoutMs: number;
                maxOutputBytes: number;
                maximumSpendUsd: number | null;
            };
            createdAt: string;
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        policySnapshot: {
            modelId: string;
            provider: string;
            upstreamModelId: string;
            configurationHash: string;
        } | null;
        configuration: {
            request: {
                schemaVersion: "openpond.modelTasksetRunRequest.v1";
                operationId: string;
                teamId: string;
                modelProjectId: string | null;
                name?: string | undefined;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                policy: {
                    kind: "hosted_harness";
                    modelId: string;
                    maxOutputTokens?: number | undefined;
                    temperature?: number | undefined;
                    topP?: number | undefined;
                    localRuntime?: {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                    reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                    profileRepositoryId: string;
                    source: {
                        profileId: string;
                        sourceRevision: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        catalogHash: string;
                        definitionId: string;
                        definitionHash: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        environmentHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                    };
                    modelConfigurationHash: string;
                    packageHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                } | {
                    kind: "hosted_chat";
                    modelId: string;
                    localRuntime?: {
                        providerId: "claude-code";
                        configurationHash: string;
                        executableHash: string;
                        version: string;
                        capabilityHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                        maximumTurns: number;
                        holdOpen: boolean;
                    } | {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | {
                        providerId: "custom-openai-compatible";
                        configurationHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    harness?: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    } | undefined;
                    messages?: {
                        role: "assistant" | "system" | "user";
                        content: string;
                    }[] | undefined;
                    maxOutputTokens: number;
                    temperature: number;
                    topP: number;
                } | {
                    kind: "fixture";
                };
                population: {
                    receiptId: string;
                    taskId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
            };
            maximumCostUsd: number;
            graders: {
                id: string;
                version: string;
                contentHash: string;
                name?: string | undefined;
                feedbackKey: string;
                release: {
                    id: string;
                    revision: number;
                    contentHash: string;
                } | null;
                mappings?: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[] | undefined;
            }[];
            admissionRequestHash?: string | undefined;
            sourceExperimentId?: string | undefined;
            configurationHash: string;
        };
    }>;
    /** Duplicate uses the original run snapshot; edits are submitted with run(). */
    duplicate(id: string, operationId: string, signal?: AbortSignal): Promise<{
        summary: {
            schemaVersion: "openpond.modelTasksetRunSummary.v1";
            id: string;
            revision: number;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            operationId: string;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policyKind: "fixture" | "hosted_chat" | "hosted_harness";
            manifestHash: string;
            status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
            totalCount: number;
            counts: {
                pending: number;
                running: number;
                completed: number;
                failed: number;
                cancelled: number;
            };
            createdAt: string;
            startedAt: string | null;
            completedAt: string | null;
            cleanupComplete: boolean;
            resultAvailable: boolean;
            score: number | null;
            metricName: string;
            error: {
                code: string;
                message: string;
            } | null;
        };
        request: {
            schemaVersion: "openpond.modelTasksetRunRequest.v1";
            operationId: string;
            teamId: string;
            modelProjectId: string | null;
            name?: string | undefined;
            project?: {
                id: string;
                revision: number;
                contentHash: string;
                targetId: string | null;
            } | undefined;
            taskset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            policy: {
                kind: "hosted_harness";
                modelId: string;
                maxOutputTokens?: number | undefined;
                temperature?: number | undefined;
                topP?: number | undefined;
                localRuntime?: {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
                reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                profileRepositoryId: string;
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                modelConfigurationHash: string;
                packageHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
            } | {
                kind: "hosted_chat";
                modelId: string;
                localRuntime?: {
                    providerId: "claude-code";
                    configurationHash: string;
                    executableHash: string;
                    version: string;
                    capabilityHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                    maximumTurns: number;
                    holdOpen: boolean;
                } | {
                    providerId: "codex";
                    configurationHash: string;
                    accountHash: string;
                    reasoningEffort: "high" | "low" | "medium" | "xhigh";
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | {
                    providerId: "custom-openai-compatible";
                    configurationHash: string;
                    maximumRequestCostUsd: number;
                    requestTimeoutMs: number;
                } | undefined;
                candidate?: {
                    artifactId: string;
                    contentHash: string;
                    preparationId: string;
                    dispatchId: string;
                    baseProfileId: string;
                    workerImageDigest: string;
                } | undefined;
                harness?: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                } | undefined;
                messages?: {
                    role: "assistant" | "system" | "user";
                    content: string;
                }[] | undefined;
                maxOutputTokens: number;
                temperature: number;
                topP: number;
            } | {
                kind: "fixture";
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
        };
        manifest: {
            schemaVersion: "openpond.tasksetRunManifest.v1";
            id: string;
            tasksetRelease: {
                id: string;
                contentHash: string;
            };
            packageHash: string;
            execution: {
                kind: "taskset";
                environmentRelease: {
                    id: string;
                    contentHash: string;
                };
                verifierSetRelease: {
                    id: string;
                    contentHash: string;
                };
                policyHash: string;
            } | {
                kind: "harness";
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
            };
            profileEvaluation?: {
                profileId: string;
                sourceRevision: string;
                harnessRelease: {
                    id: string;
                    contentHash: string;
                };
                catalogHash: string;
                definitionId: string;
                definitionHash: string;
                target: {
                    kind: "profile";
                } | {
                    kind: "workflow";
                    workflowId: string;
                } | {
                    kind: "skill";
                    skillPath: string;
                } | {
                    kind: "agent_action";
                    actionId: string;
                };
                environmentHash: string;
                externalDatasetBinding?: {
                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                    dataset: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    };
                    packageHash: string;
                    profileId: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    declaredProfileCatalogHash: string | null;
                    protectedProfileClosureHash: string;
                    recordedOrigin?: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        originalEvidence: {
                            id: string;
                            contentHash: string;
                        };
                        members: {
                            caseId: string;
                            seed: string;
                            fixtureId: string;
                            sourceId: string;
                            snapshotHash: string;
                            boundaryRevisionHash: string;
                        }[];
                    } | undefined;
                    gradingSource?: {
                        pass: {
                            id: string;
                            contentHash: string;
                        };
                        evidence: {
                            id: string;
                            contentHash: string;
                        };
                    } | undefined;
                    split: "frozen_eval" | "test" | "train" | "validation";
                    population: {
                        taskId: string;
                        seed: string;
                        fixtureId: string | null;
                    }[];
                    evaluators: {
                        release: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        feedbackKey: string;
                        configurationHash: string;
                        output: "boolean" | "category" | "score";
                        categories: string[];
                    }[];
                    fieldMappingsHash: string;
                    fieldMappings: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[];
                    environmentHash: string;
                    privateDatasetClosureHash: string;
                    criterion: {
                        minimumPassRate: number;
                        requireComplete: boolean;
                    };
                    contentHash: string;
                } | undefined;
                sourceCandidate?: {
                    candidateId: string;
                    frozenRevision: number;
                    frozenHash: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    protectedClosureHash: string;
                } | undefined;
            } | undefined;
            policy: {
                kind: "model";
                model: {
                    provider: string;
                    model: string;
                    revision: string | null;
                    artifactHash: string | null;
                    tokenizerRevision: string | null;
                    chatTemplateHash: string | null;
                };
                configurationHash: string;
            } | {
                kind: "fixture";
            };
            gradingRole: "evaluation";
            metricPolicy: {
                schemaVersion: "openpond.tasksetMetricPolicy.v1";
                primaryMetric: string;
                aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
                missingReward: "exclude" | "zero";
                taskWeights?: Record<string, number> | undefined;
                customAggregator: {
                    module: string;
                    exportName: string;
                    contentHash: string;
                    timeoutMs: number;
                    networkPolicy: "none";
                } | null;
            };
            population: {
                receiptId: string;
                taskId: string;
                seed: string;
                fixtureId: string | null;
            }[];
            runtimeTarget: {
                adapterId: string;
                placement: "colocated" | "local" | "provider_native" | "remote";
                runtimeVersion: string;
                capabilityReceipt: string;
            };
            limits: {
                maxTurns: number;
                timeoutMs: number;
                maxOutputBytes: number;
                maximumSpendUsd: number | null;
            };
            createdAt: string;
            metadata: Record<string, unknown>;
            contentHash: string;
        };
        policySnapshot: {
            modelId: string;
            provider: string;
            upstreamModelId: string;
            configurationHash: string;
        } | null;
        configuration: {
            request: {
                schemaVersion: "openpond.modelTasksetRunRequest.v1";
                operationId: string;
                teamId: string;
                modelProjectId: string | null;
                name?: string | undefined;
                project?: {
                    id: string;
                    revision: number;
                    contentHash: string;
                    targetId: string | null;
                } | undefined;
                taskset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                policy: {
                    kind: "hosted_harness";
                    modelId: string;
                    maxOutputTokens?: number | undefined;
                    temperature?: number | undefined;
                    topP?: number | undefined;
                    localRuntime?: {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                    reasoningEffort?: "high" | "low" | "max" | "medium" | "off" | "xhigh" | undefined;
                    profileRepositoryId: string;
                    source: {
                        profileId: string;
                        sourceRevision: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        catalogHash: string;
                        definitionId: string;
                        definitionHash: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        environmentHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                    };
                    modelConfigurationHash: string;
                    packageHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                } | {
                    kind: "hosted_chat";
                    modelId: string;
                    localRuntime?: {
                        providerId: "claude-code";
                        configurationHash: string;
                        executableHash: string;
                        version: string;
                        capabilityHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                        maximumTurns: number;
                        holdOpen: boolean;
                    } | {
                        providerId: "codex";
                        configurationHash: string;
                        accountHash: string;
                        reasoningEffort: "high" | "low" | "medium" | "xhigh";
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | {
                        providerId: "custom-openai-compatible";
                        configurationHash: string;
                        maximumRequestCostUsd: number;
                        requestTimeoutMs: number;
                    } | undefined;
                    candidate?: {
                        artifactId: string;
                        contentHash: string;
                        preparationId: string;
                        dispatchId: string;
                        baseProfileId: string;
                        workerImageDigest: string;
                    } | undefined;
                    harness?: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    } | undefined;
                    messages?: {
                        role: "assistant" | "system" | "user";
                        content: string;
                    }[] | undefined;
                    maxOutputTokens: number;
                    temperature: number;
                    topP: number;
                } | {
                    kind: "fixture";
                };
                population: {
                    receiptId: string;
                    taskId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
            };
            maximumCostUsd: number;
            graders: {
                id: string;
                version: string;
                contentHash: string;
                name?: string | undefined;
                feedbackKey: string;
                release: {
                    id: string;
                    revision: number;
                    contentHash: string;
                } | null;
                mappings?: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[] | undefined;
            }[];
            admissionRequestHash?: string | undefined;
            sourceExperimentId?: string | undefined;
            configurationHash: string;
        };
    }>;
    score(value: ExperimentScoringRequest, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.experimentScoringPass.v1";
        id: string;
        teamId: string;
        revision: number;
        request: {
            operationId: string;
            execution: {
                id: string;
                contentHash: string;
            };
            executionKind?: "recorded_evidence" | undefined;
            graders: {
                id: string;
                contentHash: string;
                revision: number;
            }[];
            maximumCostUsd: number;
            mappings?: {
                graderId: string;
                fields: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[];
            }[] | undefined;
        };
        graders: {
            id: string;
            version: string;
            contentHash: string;
            name?: string | undefined;
            feedbackKey: string;
            release: {
                id: string;
                revision: number;
                contentHash: string;
            } | null;
            mappings?: {
                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                path: string[];
                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                sourcePath: string[];
            }[] | undefined;
        }[];
        status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
        totalCount: number;
        counts: {
            pending: number;
            running: number;
            scored: number;
            unavailable: number;
            failed: number;
            cancelled: number;
        };
        resultAvailable: boolean;
        createdAt: string;
        startedAt: string | null;
        completedAt: string | null;
        error: {
            code: string;
            message: string;
        } | null;
        contentHash: string;
    }>;
    scoringPass(id: string, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.experimentScoringPass.v1";
        id: string;
        teamId: string;
        revision: number;
        request: {
            operationId: string;
            execution: {
                id: string;
                contentHash: string;
            };
            executionKind?: "recorded_evidence" | undefined;
            graders: {
                id: string;
                contentHash: string;
                revision: number;
            }[];
            maximumCostUsd: number;
            mappings?: {
                graderId: string;
                fields: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[];
            }[] | undefined;
        };
        graders: {
            id: string;
            version: string;
            contentHash: string;
            name?: string | undefined;
            feedbackKey: string;
            release: {
                id: string;
                revision: number;
                contentHash: string;
            } | null;
            mappings?: {
                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                path: string[];
                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                sourcePath: string[];
            }[] | undefined;
        }[];
        status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
        totalCount: number;
        counts: {
            pending: number;
            running: number;
            scored: number;
            unavailable: number;
            failed: number;
            cancelled: number;
        };
        resultAvailable: boolean;
        createdAt: string;
        startedAt: string | null;
        completedAt: string | null;
        error: {
            code: string;
            message: string;
        } | null;
        contentHash: string;
    }>;
    scoringPasses(executionId: string, options?: {
        afterId?: string;
        executionKind?: "recorded_evidence";
        signal?: AbortSignal;
    }): Promise<{
        items: {
            schemaVersion: "openpond.experimentScoringPass.v1";
            id: string;
            teamId: string;
            revision: number;
            request: {
                operationId: string;
                execution: {
                    id: string;
                    contentHash: string;
                };
                executionKind?: "recorded_evidence" | undefined;
                graders: {
                    id: string;
                    contentHash: string;
                    revision: number;
                }[];
                maximumCostUsd: number;
                mappings?: {
                    graderId: string;
                    fields: {
                        destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                        path: string[];
                        source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                        sourcePath: string[];
                    }[];
                }[] | undefined;
            };
            graders: {
                id: string;
                version: string;
                contentHash: string;
                name?: string | undefined;
                feedbackKey: string;
                release: {
                    id: string;
                    revision: number;
                    contentHash: string;
                } | null;
                mappings?: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[] | undefined;
            }[];
            status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
            totalCount: number;
            counts: {
                pending: number;
                running: number;
                scored: number;
                unavailable: number;
                failed: number;
                cancelled: number;
            };
            resultAvailable: boolean;
            createdAt: string;
            startedAt: string | null;
            completedAt: string | null;
            error: {
                code: string;
                message: string;
            } | null;
            contentHash: string;
        }[];
        nextCursor: string | null;
    }>;
    cancelScoringPass(id: string, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.experimentScoringPass.v1";
        id: string;
        teamId: string;
        revision: number;
        request: {
            operationId: string;
            execution: {
                id: string;
                contentHash: string;
            };
            executionKind?: "recorded_evidence" | undefined;
            graders: {
                id: string;
                contentHash: string;
                revision: number;
            }[];
            maximumCostUsd: number;
            mappings?: {
                graderId: string;
                fields: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[];
            }[] | undefined;
        };
        graders: {
            id: string;
            version: string;
            contentHash: string;
            name?: string | undefined;
            feedbackKey: string;
            release: {
                id: string;
                revision: number;
                contentHash: string;
            } | null;
            mappings?: {
                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                path: string[];
                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                sourcePath: string[];
            }[] | undefined;
        }[];
        status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
        totalCount: number;
        counts: {
            pending: number;
            running: number;
            scored: number;
            unavailable: number;
            failed: number;
            cancelled: number;
        };
        resultAvailable: boolean;
        createdAt: string;
        startedAt: string | null;
        completedAt: string | null;
        error: {
            code: string;
            message: string;
        } | null;
        contentHash: string;
    }>;
    scoringResult(id: string, signal?: AbortSignal): Promise<{
        manifest: {
            schemaVersion: "openpond.experimentManifest.v1";
            id: string;
            name: string;
            teamId: string;
            operationId: string;
            maximumCostUsd: number | null;
            dataset: {
                id: string;
                contentHash: string;
                revision: number;
            };
            target: {
                kind: "model";
                modelId: string;
                configurationHash: string;
            } | {
                kind: "harness";
                source: {
                    profileId: string;
                    sourceRevision: string;
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    catalogHash: string;
                    definitionId: string;
                    definitionHash: string;
                    target: {
                        kind: "profile";
                    } | {
                        kind: "workflow";
                        workflowId: string;
                    } | {
                        kind: "skill";
                        skillPath: string;
                    } | {
                        kind: "agent_action";
                        actionId: string;
                    };
                    environmentHash: string;
                    externalDatasetBinding?: {
                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                        dataset: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        };
                        packageHash: string;
                        profileId: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        declaredProfileCatalogHash: string | null;
                        protectedProfileClosureHash: string;
                        recordedOrigin?: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            originalEvidence: {
                                id: string;
                                contentHash: string;
                            };
                            members: {
                                caseId: string;
                                seed: string;
                                fixtureId: string;
                                sourceId: string;
                                snapshotHash: string;
                                boundaryRevisionHash: string;
                            }[];
                        } | undefined;
                        gradingSource?: {
                            pass: {
                                id: string;
                                contentHash: string;
                            };
                            evidence: {
                                id: string;
                                contentHash: string;
                            };
                        } | undefined;
                        split: "frozen_eval" | "test" | "train" | "validation";
                        population: {
                            taskId: string;
                            seed: string;
                            fixtureId: string | null;
                        }[];
                        evaluators: {
                            release: {
                                id: string;
                                contentHash: string;
                                revision: string | number;
                            };
                            feedbackKey: string;
                            configurationHash: string;
                            output: "boolean" | "category" | "score";
                            categories: string[];
                        }[];
                        fieldMappingsHash: string;
                        fieldMappings: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[];
                        environmentHash: string;
                        privateDatasetClosureHash: string;
                        criterion: {
                            minimumPassRate: number;
                            requireComplete: boolean;
                        };
                        contentHash: string;
                    } | undefined;
                    sourceCandidate?: {
                        candidateId: string;
                        frozenRevision: number;
                        frozenHash: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        protectedClosureHash: string;
                    } | undefined;
                };
                model: {
                    modelId: string;
                    configurationHash: string;
                };
            } | {
                kind: "agent";
                source: {
                    harnessRelease: {
                        id: string;
                        contentHash: string;
                    };
                    agentSnapshot: {
                        id: string;
                        contentHash: string;
                    };
                    sourcePackageHash: string;
                };
                model: {
                    modelId: string;
                    configurationHash: string;
                };
            } | {
                kind: "fixture";
                configurationHash: string;
            };
            execution?: {
                packageHash: string;
                runtimeTargetHash: string;
                metricPolicyHash: string;
                compatibility?: {
                    protocol: "openpond.evaluation-execution.v1";
                    targetKind: "agent" | "fixture" | "harness" | "model";
                } | undefined;
            } | undefined;
            lineage?: {
                definition: {
                    id: string;
                    contentHash: string;
                    revision: number;
                } | null;
                execution: {
                    id: string;
                    contentHash: string;
                };
                scoringPassId: string | null;
                humanProjection?: {
                    originalManifest: {
                        id: string;
                        contentHash: string;
                    };
                    selectionHash: string;
                    rulesHash: string;
                } | undefined;
            } | undefined;
            evaluators: {
                release: {
                    id: string;
                    contentHash: string;
                    revision: string | number;
                };
                feedbackKey: string;
                configurationHash?: string | undefined;
                output: "boolean" | "category" | "score";
                categories: string[];
            }[];
            population: {
                caseId: string;
                seed: string;
                fixtureId: string | null;
            }[];
            createdAt: string;
            contentHash: string;
        };
        result: {
            schemaVersion: "openpond.experimentResult.v1";
            manifest: {
                id: string;
                contentHash: string;
            };
            status: "cancelled" | "completed" | "failed";
            cases: {
                identity: {
                    caseId: string;
                    seed: string;
                    fixtureId: string | null;
                };
                status: "cancelled" | "completed" | "failed" | "unavailable";
                output: unknown;
                error: {
                    code: string;
                    message: string;
                } | null;
                feedback: {
                    feedbackKey: string;
                    evaluator: {
                        id: string;
                        contentHash: string;
                        revision: string | number;
                    };
                    status: "failed" | "pending" | "scored" | "unavailable";
                    value: string | number | boolean | null;
                    passed?: boolean | null | undefined;
                    reasoning: string | null;
                    evidenceRefs: {
                        id: string;
                        contentHash: string;
                        mediaType: string | null;
                        sizeBytes: number | null;
                    }[];
                }[];
                usage: {
                    inputTokens: number | null;
                    outputTokens: number | null;
                    totalTokens: number | null;
                    costUsd: number | null;
                    latencyMs: number | null;
                };
                traceRef: {
                    id: string;
                    contentHash: string;
                    mediaType: string | null;
                    sizeBytes: number | null;
                } | null;
                startedAt: string | null;
                completedAt: string | null;
            }[];
            completedAt: string;
            contentHash: string;
        };
        executionId: string;
        passId: string;
    }>;
    compare(baselineId: string, candidateId: string, signal?: AbortSignal): Promise<{
        baseline: {
            manifest: {
                schemaVersion: "openpond.experimentManifest.v1";
                id: string;
                name: string;
                teamId: string;
                operationId: string;
                maximumCostUsd: number | null;
                dataset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                target: {
                    kind: "model";
                    modelId: string;
                    configurationHash: string;
                } | {
                    kind: "harness";
                    source: {
                        profileId: string;
                        sourceRevision: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        catalogHash: string;
                        definitionId: string;
                        definitionHash: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        environmentHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                    };
                    model: {
                        modelId: string;
                        configurationHash: string;
                    };
                } | {
                    kind: "agent";
                    source: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    };
                    model: {
                        modelId: string;
                        configurationHash: string;
                    };
                } | {
                    kind: "fixture";
                    configurationHash: string;
                };
                execution?: {
                    packageHash: string;
                    runtimeTargetHash: string;
                    metricPolicyHash: string;
                    compatibility?: {
                        protocol: "openpond.evaluation-execution.v1";
                        targetKind: "agent" | "fixture" | "harness" | "model";
                    } | undefined;
                } | undefined;
                lineage?: {
                    definition: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    } | null;
                    execution: {
                        id: string;
                        contentHash: string;
                    };
                    scoringPassId: string | null;
                    humanProjection?: {
                        originalManifest: {
                            id: string;
                            contentHash: string;
                        };
                        selectionHash: string;
                        rulesHash: string;
                    } | undefined;
                } | undefined;
                evaluators: {
                    release: {
                        id: string;
                        contentHash: string;
                        revision: string | number;
                    };
                    feedbackKey: string;
                    configurationHash?: string | undefined;
                    output: "boolean" | "category" | "score";
                    categories: string[];
                }[];
                population: {
                    caseId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
                createdAt: string;
                contentHash: string;
            };
            result: {
                schemaVersion: "openpond.experimentResult.v1";
                manifest: {
                    id: string;
                    contentHash: string;
                };
                status: "cancelled" | "completed" | "failed";
                cases: {
                    identity: {
                        caseId: string;
                        seed: string;
                        fixtureId: string | null;
                    };
                    status: "cancelled" | "completed" | "failed" | "unavailable";
                    output: unknown;
                    error: {
                        code: string;
                        message: string;
                    } | null;
                    feedback: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        status: "failed" | "pending" | "scored" | "unavailable";
                        value: string | number | boolean | null;
                        passed?: boolean | null | undefined;
                        reasoning: string | null;
                        evidenceRefs: {
                            id: string;
                            contentHash: string;
                            mediaType: string | null;
                            sizeBytes: number | null;
                        }[];
                    }[];
                    usage: {
                        inputTokens: number | null;
                        outputTokens: number | null;
                        totalTokens: number | null;
                        costUsd: number | null;
                        latencyMs: number | null;
                    };
                    traceRef: {
                        id: string;
                        contentHash: string;
                        mediaType: string | null;
                        sizeBytes: number | null;
                    } | null;
                    startedAt: string | null;
                    completedAt: string | null;
                }[];
                completedAt: string;
                contentHash: string;
            };
            executionId: string;
            passId: string | null;
        };
        candidate: {
            manifest: {
                schemaVersion: "openpond.experimentManifest.v1";
                id: string;
                name: string;
                teamId: string;
                operationId: string;
                maximumCostUsd: number | null;
                dataset: {
                    id: string;
                    contentHash: string;
                    revision: number;
                };
                target: {
                    kind: "model";
                    modelId: string;
                    configurationHash: string;
                } | {
                    kind: "harness";
                    source: {
                        profileId: string;
                        sourceRevision: string;
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        catalogHash: string;
                        definitionId: string;
                        definitionHash: string;
                        target: {
                            kind: "profile";
                        } | {
                            kind: "workflow";
                            workflowId: string;
                        } | {
                            kind: "skill";
                            skillPath: string;
                        } | {
                            kind: "agent_action";
                            actionId: string;
                        };
                        environmentHash: string;
                        externalDatasetBinding?: {
                            schemaVersion: "openpond.profileExternalDatasetBinding.v1";
                            dataset: {
                                id: string;
                                contentHash: string;
                                revision: number;
                            };
                            packageHash: string;
                            profileId: string;
                            target: {
                                kind: "profile";
                            } | {
                                kind: "workflow";
                                workflowId: string;
                            } | {
                                kind: "skill";
                                skillPath: string;
                            } | {
                                kind: "agent_action";
                                actionId: string;
                            };
                            declaredProfileCatalogHash: string | null;
                            protectedProfileClosureHash: string;
                            recordedOrigin?: {
                                execution: {
                                    id: string;
                                    contentHash: string;
                                };
                                originalEvidence: {
                                    id: string;
                                    contentHash: string;
                                };
                                members: {
                                    caseId: string;
                                    seed: string;
                                    fixtureId: string;
                                    sourceId: string;
                                    snapshotHash: string;
                                    boundaryRevisionHash: string;
                                }[];
                            } | undefined;
                            gradingSource?: {
                                pass: {
                                    id: string;
                                    contentHash: string;
                                };
                                evidence: {
                                    id: string;
                                    contentHash: string;
                                };
                            } | undefined;
                            split: "frozen_eval" | "test" | "train" | "validation";
                            population: {
                                taskId: string;
                                seed: string;
                                fixtureId: string | null;
                            }[];
                            evaluators: {
                                release: {
                                    id: string;
                                    contentHash: string;
                                    revision: string | number;
                                };
                                feedbackKey: string;
                                configurationHash: string;
                                output: "boolean" | "category" | "score";
                                categories: string[];
                            }[];
                            fieldMappingsHash: string;
                            fieldMappings: {
                                graderId: string;
                                fields: {
                                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    path: string[];
                                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                    sourcePath: string[];
                                }[];
                            }[];
                            environmentHash: string;
                            privateDatasetClosureHash: string;
                            criterion: {
                                minimumPassRate: number;
                                requireComplete: boolean;
                            };
                            contentHash: string;
                        } | undefined;
                        sourceCandidate?: {
                            candidateId: string;
                            frozenRevision: number;
                            frozenHash: string;
                            harnessRelease: {
                                id: string;
                                contentHash: string;
                            };
                            protectedClosureHash: string;
                        } | undefined;
                    };
                    model: {
                        modelId: string;
                        configurationHash: string;
                    };
                } | {
                    kind: "agent";
                    source: {
                        harnessRelease: {
                            id: string;
                            contentHash: string;
                        };
                        agentSnapshot: {
                            id: string;
                            contentHash: string;
                        };
                        sourcePackageHash: string;
                    };
                    model: {
                        modelId: string;
                        configurationHash: string;
                    };
                } | {
                    kind: "fixture";
                    configurationHash: string;
                };
                execution?: {
                    packageHash: string;
                    runtimeTargetHash: string;
                    metricPolicyHash: string;
                    compatibility?: {
                        protocol: "openpond.evaluation-execution.v1";
                        targetKind: "agent" | "fixture" | "harness" | "model";
                    } | undefined;
                } | undefined;
                lineage?: {
                    definition: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    } | null;
                    execution: {
                        id: string;
                        contentHash: string;
                    };
                    scoringPassId: string | null;
                    humanProjection?: {
                        originalManifest: {
                            id: string;
                            contentHash: string;
                        };
                        selectionHash: string;
                        rulesHash: string;
                    } | undefined;
                } | undefined;
                evaluators: {
                    release: {
                        id: string;
                        contentHash: string;
                        revision: string | number;
                    };
                    feedbackKey: string;
                    configurationHash?: string | undefined;
                    output: "boolean" | "category" | "score";
                    categories: string[];
                }[];
                population: {
                    caseId: string;
                    seed: string;
                    fixtureId: string | null;
                }[];
                createdAt: string;
                contentHash: string;
            };
            result: {
                schemaVersion: "openpond.experimentResult.v1";
                manifest: {
                    id: string;
                    contentHash: string;
                };
                status: "cancelled" | "completed" | "failed";
                cases: {
                    identity: {
                        caseId: string;
                        seed: string;
                        fixtureId: string | null;
                    };
                    status: "cancelled" | "completed" | "failed" | "unavailable";
                    output: unknown;
                    error: {
                        code: string;
                        message: string;
                    } | null;
                    feedback: {
                        feedbackKey: string;
                        evaluator: {
                            id: string;
                            contentHash: string;
                            revision: string | number;
                        };
                        status: "failed" | "pending" | "scored" | "unavailable";
                        value: string | number | boolean | null;
                        passed?: boolean | null | undefined;
                        reasoning: string | null;
                        evidenceRefs: {
                            id: string;
                            contentHash: string;
                            mediaType: string | null;
                            sizeBytes: number | null;
                        }[];
                    }[];
                    usage: {
                        inputTokens: number | null;
                        outputTokens: number | null;
                        totalTokens: number | null;
                        costUsd: number | null;
                        latencyMs: number | null;
                    };
                    traceRef: {
                        id: string;
                        contentHash: string;
                        mediaType: string | null;
                        sizeBytes: number | null;
                    } | null;
                    startedAt: string | null;
                    completedAt: string | null;
                }[];
                completedAt: string;
                contentHash: string;
            };
            executionId: string;
            passId: string | null;
        };
        comparison: import("@openpond/evals/experiments").ExperimentComparison;
    }>;
    private details;
    private pass;
    private request;
}
//# sourceMappingURL=experiment-client.d.ts.map