import { type ExperimentImprovementCommand } from "./experiment-improvement-contracts.js";
import { HostedProfileCandidateCommandSchema } from "./experiment-improvement-hosted-adoption.js";
export declare class ExperimentImprovementClient {
    private readonly options;
    private readonly origin;
    constructor(options: {
        baseUrl: string;
        apiKey: string;
        teamId: string;
        actorId: string;
        fetch?: typeof fetch;
    });
    hostedCandidate(raw: import("zod").input<typeof HostedProfileCandidateCommandSchema>, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.hostedProfileCandidateAdoption.v1";
        id: string;
        operationId: string;
        actorId: string;
        teamId: string;
        candidateId: string;
        exportHash: string;
        executionOrigin: "hosted_execution" | "owner_attested_local";
        qualification: {
            kind: "hosted_execution" | "owner_attested_local";
            ownerActorId: string;
            teamId: string;
            originalEvidence: {
                id: string;
                contentHash: string;
            };
            baseline: {
                id: string;
                contentHash: string;
            };
            candidate: {
                id: string;
                contentHash: string;
            };
            comparisonHash: string;
            recipe: {
                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;
                };
                scoring?: {
                    sourcePass: {
                        id: string;
                        contentHash: string;
                    };
                    graders: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    }[];
                    mappings?: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[] | undefined;
                    maximumCostUsd: number;
                } | undefined;
                modelId: string;
                maximumCostUsd: number;
            };
        };
        testedCandidateRelease: {
            id: string;
            contentHash: string;
        };
        activeRelease: {
            id: string;
            contentHash: string;
        };
        expectedCommit: string;
        committedProfileGit: string;
        executableSourceHash: string;
        protectedClosureHash: string;
        createdAt: string;
        contentHash: string;
    }>;
    command(raw: ExperimentImprovementCommand, signal?: AbortSignal): Promise<{
        schemaVersion: "openpond.experimentImprovement.v1";
        id: string;
        operationId: string;
        requestHash: string;
        actorId: string;
        teamId: string;
        projectId: string | null;
        ownerWorkspaceId: string;
        ownerRevision: number;
        ownerSourceRevision: string;
        baseRelease: {
            id: string;
            contentHash: string;
        };
        profileRef: {
            source: "github" | "local" | "openpond_git";
            repositoryId: string;
            profileId: string;
        };
        baseProfileSourceRevision: string;
        evidence: {
            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;
            };
        };
        component: {
            kind: "agent" | "instruction" | "skill" | "workflow";
            path: string;
            workflowId?: string | undefined;
        };
        mode: "llm_assisted" | "manual";
        status: "accepted" | "adopting" | "authoring" | "authoring_queued" | "cancelled" | "declined" | "draft" | "failed" | "frozen" | "ready_for_review" | "rolled_back" | "testing";
        revision: number;
        limits: {
            maximumCostUsd: number;
            maximumAuthoringSteps: number;
            maximumDurationMs: number;
        };
        authoringSteps: number;
        work: {
            sessionId: string;
            turnId: string;
            revision: number;
            startedAt: string;
        } | null;
        frozen: {
            release: {
                id: string;
                contentHash: string;
            };
            sourceRevision: string;
            profileSourceRevision: string;
            authoringHash: string;
            partitionHash: string;
            executableSourceHash: string;
            protectedClosureHash: string;
            candidateRevision: number;
            diff: {
                path: string;
                before: string | null;
                after: string | null;
            }[];
        } | null;
        test: {
            recipe: {
                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;
                };
                scoring?: {
                    sourcePass: {
                        id: string;
                        contentHash: string;
                    };
                    graders: {
                        id: string;
                        contentHash: string;
                        revision: number;
                    }[];
                    mappings?: {
                        graderId: string;
                        fields: {
                            destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            path: string[];
                            source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                            sourcePath: string[];
                        }[];
                    }[] | undefined;
                    maximumCostUsd: number;
                } | undefined;
                modelId: string;
                maximumCostUsd: number;
            };
            recipeHash: string;
            baselineOperationId: string;
            candidateOperationId: string;
            cancelRequestedAt: string | null;
            dispatching: {
                kind: "baseline" | "candidate";
                token: string;
                pid: number;
                processStart: string | null;
                startedAt: string;
            } | null;
        } | null;
        comparison: {
            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;
                };
            };
            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;
                };
            };
            frozenHash: string;
            humanProjection?: {
                schemaVersion: "openpond.humanComparisonProjection.v1";
                teamId: string;
                projectId: string;
                selections: {
                    rules: ({
                        feedbackKey: string;
                        criterionId: string;
                        kind: "normalized_score";
                        minimum: number;
                        maximum: number;
                        passThreshold?: number | undefined;
                    } | {
                        feedbackKey: string;
                        criterionId: string;
                        kind: "boolean";
                    } | {
                        feedbackKey: string;
                        criterionId: string;
                        kind: "category";
                    } | {
                        feedbackKey: string;
                        criterionId: string;
                        kind: "preference_score";
                        tieScore: number | null;
                    })[];
                    baseline: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        resultHash: string;
                        reviews: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                        }[];
                    };
                    candidate: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        resultHash: string;
                        reviews: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                        }[];
                    };
                };
                original: {
                    baseline: {
                        id: string;
                        manifestHash: string;
                        resultHash: string;
                    };
                    candidate: {
                        id: string;
                        manifestHash: string;
                        resultHash: string;
                    };
                };
                humanResults: {
                    baseline: {
                        schemaVersion: "openpond.humanResultView.v1";
                        executionId: string;
                        executionHash: string;
                        selection: {
                            id: string;
                            revision: number;
                            contentHash: string;
                        }[];
                        coverage: {
                            pending: number;
                            submitted: number;
                            accepted: number;
                            rejected: number;
                            cancelled: number;
                        };
                        results: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            } | null;
                            attemptIds: string[];
                            mode: "individual" | "pairwise";
                            origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                            status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                            grader: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            answers: {
                                criterionId: string;
                                value: string | number | boolean | null;
                                abstain: boolean;
                                note: string;
                                strength?: "moderate" | "slight" | "strong" | undefined;
                            }[];
                        }[];
                        contentHash: string;
                    };
                    candidate: {
                        schemaVersion: "openpond.humanResultView.v1";
                        executionId: string;
                        executionHash: string;
                        selection: {
                            id: string;
                            revision: number;
                            contentHash: string;
                        }[];
                        coverage: {
                            pending: number;
                            submitted: number;
                            accepted: number;
                            rejected: number;
                            cancelled: number;
                        };
                        results: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            } | null;
                            attemptIds: string[];
                            mode: "individual" | "pairwise";
                            origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                            status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                            grader: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            answers: {
                                criterionId: string;
                                value: string | number | boolean | null;
                                abstain: boolean;
                                note: string;
                                strength?: "moderate" | "slight" | "strong" | undefined;
                            }[];
                        }[];
                        contentHash: string;
                    };
                };
                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;
                    };
                };
                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;
                    };
                };
                contentHash: string;
            } | undefined;
        } | null;
        adoptionIntent: {
            operationId: string;
            expectedOwnerRevision: number;
            frozenHash: string;
            humanProjection?: {
                schemaVersion: "openpond.humanComparisonProjection.v1";
                teamId: string;
                projectId: string;
                selections: {
                    rules: ({
                        feedbackKey: string;
                        criterionId: string;
                        kind: "normalized_score";
                        minimum: number;
                        maximum: number;
                        passThreshold?: number | undefined;
                    } | {
                        feedbackKey: string;
                        criterionId: string;
                        kind: "boolean";
                    } | {
                        feedbackKey: string;
                        criterionId: string;
                        kind: "category";
                    } | {
                        feedbackKey: string;
                        criterionId: string;
                        kind: "preference_score";
                        tieScore: number | null;
                    })[];
                    baseline: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        resultHash: string;
                        reviews: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                        }[];
                    };
                    candidate: {
                        execution: {
                            id: string;
                            contentHash: string;
                        };
                        resultHash: string;
                        reviews: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                        }[];
                    };
                };
                original: {
                    baseline: {
                        id: string;
                        manifestHash: string;
                        resultHash: string;
                    };
                    candidate: {
                        id: string;
                        manifestHash: string;
                        resultHash: string;
                    };
                };
                humanResults: {
                    baseline: {
                        schemaVersion: "openpond.humanResultView.v1";
                        executionId: string;
                        executionHash: string;
                        selection: {
                            id: string;
                            revision: number;
                            contentHash: string;
                        }[];
                        coverage: {
                            pending: number;
                            submitted: number;
                            accepted: number;
                            rejected: number;
                            cancelled: number;
                        };
                        results: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            } | null;
                            attemptIds: string[];
                            mode: "individual" | "pairwise";
                            origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                            status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                            grader: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            answers: {
                                criterionId: string;
                                value: string | number | boolean | null;
                                abstain: boolean;
                                note: string;
                                strength?: "moderate" | "slight" | "strong" | undefined;
                            }[];
                        }[];
                        contentHash: string;
                    };
                    candidate: {
                        schemaVersion: "openpond.humanResultView.v1";
                        executionId: string;
                        executionHash: string;
                        selection: {
                            id: string;
                            revision: number;
                            contentHash: string;
                        }[];
                        coverage: {
                            pending: number;
                            submitted: number;
                            accepted: number;
                            rejected: number;
                            cancelled: number;
                        };
                        results: {
                            review: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            decision: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            } | null;
                            attemptIds: string[];
                            mode: "individual" | "pairwise";
                            origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                            status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                            grader: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            };
                            answers: {
                                criterionId: string;
                                value: string | number | boolean | null;
                                abstain: boolean;
                                note: string;
                                strength?: "moderate" | "slight" | "strong" | undefined;
                            }[];
                        }[];
                        contentHash: string;
                    };
                };
                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;
                    };
                };
                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;
                    };
                };
                contentHash: string;
            } | undefined;
        } | null;
        acceptance: {
            id: string;
            contentHash: string;
        } | null;
        rollback: {
            id: string;
            contentHash: string;
        } | null;
        error: string | null;
        createdAt: string;
        updatedAt: string;
        contentHash: string;
    } | {
        candidateId: string;
        actorId: string;
        teamId: string;
        projectId: string | null;
        candidateRevision: number;
        recipeHash: string;
        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;
            };
        };
        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;
            };
        };
        contentHash: string;
    } | {
        teamId: string;
        evidence: {
            id: string;
            contentHash: string;
        };
        scoring?: {
            sourcePass: {
                id: string;
                contentHash: string;
            };
            graders: {
                id: string;
                contentHash: string;
                revision: number;
            }[];
            mappings?: {
                graderId: string;
                fields: {
                    destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    path: string[];
                    source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                    sourcePath: string[];
                }[];
            }[] | undefined;
            maximumCostUsd: number;
        } | undefined;
        profiles: {
            id: string;
            name: string;
            profileRef: {
                source: "github" | "local" | "openpond_git";
                repositoryId: string;
                profileId: string;
            };
            ownerWorkspaceId: string;
            ownerRevision: number;
            baseRelease: {
                id: string;
                contentHash: string;
            };
            profileSourceRevision: string;
            components: {
                kind: "agent" | "instruction" | "skill" | "workflow";
                path: string;
                agentId?: string | undefined;
                workflowId?: string | undefined;
                label: string;
                binding: {
                    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;
                };
            }[];
        }[];
    } | {
        candidateId: string;
        candidateRevision: number;
        path: string;
        text: string;
        textHash: string;
        contentHash: string;
    } | {
        states: {
            schemaVersion: "openpond.experimentImprovement.v1";
            id: string;
            operationId: string;
            requestHash: string;
            actorId: string;
            teamId: string;
            projectId: string | null;
            ownerWorkspaceId: string;
            ownerRevision: number;
            ownerSourceRevision: string;
            baseRelease: {
                id: string;
                contentHash: string;
            };
            profileRef: {
                source: "github" | "local" | "openpond_git";
                repositoryId: string;
                profileId: string;
            };
            baseProfileSourceRevision: string;
            evidence: {
                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;
                };
            };
            component: {
                kind: "agent" | "instruction" | "skill" | "workflow";
                path: string;
                workflowId?: string | undefined;
            };
            mode: "llm_assisted" | "manual";
            status: "accepted" | "adopting" | "authoring" | "authoring_queued" | "cancelled" | "declined" | "draft" | "failed" | "frozen" | "ready_for_review" | "rolled_back" | "testing";
            revision: number;
            limits: {
                maximumCostUsd: number;
                maximumAuthoringSteps: number;
                maximumDurationMs: number;
            };
            authoringSteps: number;
            work: {
                sessionId: string;
                turnId: string;
                revision: number;
                startedAt: string;
            } | null;
            frozen: {
                release: {
                    id: string;
                    contentHash: string;
                };
                sourceRevision: string;
                profileSourceRevision: string;
                authoringHash: string;
                partitionHash: string;
                executableSourceHash: string;
                protectedClosureHash: string;
                candidateRevision: number;
                diff: {
                    path: string;
                    before: string | null;
                    after: string | null;
                }[];
            } | null;
            test: {
                recipe: {
                    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;
                    };
                    scoring?: {
                        sourcePass: {
                            id: string;
                            contentHash: string;
                        };
                        graders: {
                            id: string;
                            contentHash: string;
                            revision: number;
                        }[];
                        mappings?: {
                            graderId: string;
                            fields: {
                                destination: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                path: string[];
                                source: "evaluatorContext" | "expectedOutput" | "input" | "output";
                                sourcePath: string[];
                            }[];
                        }[] | undefined;
                        maximumCostUsd: number;
                    } | undefined;
                    modelId: string;
                    maximumCostUsd: number;
                };
                recipeHash: string;
                baselineOperationId: string;
                candidateOperationId: string;
                cancelRequestedAt: string | null;
                dispatching: {
                    kind: "baseline" | "candidate";
                    token: string;
                    pid: number;
                    processStart: string | null;
                    startedAt: string;
                } | null;
            } | null;
            comparison: {
                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;
                    };
                };
                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;
                    };
                };
                frozenHash: string;
                humanProjection?: {
                    schemaVersion: "openpond.humanComparisonProjection.v1";
                    teamId: string;
                    projectId: string;
                    selections: {
                        rules: ({
                            feedbackKey: string;
                            criterionId: string;
                            kind: "normalized_score";
                            minimum: number;
                            maximum: number;
                            passThreshold?: number | undefined;
                        } | {
                            feedbackKey: string;
                            criterionId: string;
                            kind: "boolean";
                        } | {
                            feedbackKey: string;
                            criterionId: string;
                            kind: "category";
                        } | {
                            feedbackKey: string;
                            criterionId: string;
                            kind: "preference_score";
                            tieScore: number | null;
                        })[];
                        baseline: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            resultHash: string;
                            reviews: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                            }[];
                        };
                        candidate: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            resultHash: string;
                            reviews: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                            }[];
                        };
                    };
                    original: {
                        baseline: {
                            id: string;
                            manifestHash: string;
                            resultHash: string;
                        };
                        candidate: {
                            id: string;
                            manifestHash: string;
                            resultHash: string;
                        };
                    };
                    humanResults: {
                        baseline: {
                            schemaVersion: "openpond.humanResultView.v1";
                            executionId: string;
                            executionHash: string;
                            selection: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            }[];
                            coverage: {
                                pending: number;
                                submitted: number;
                                accepted: number;
                                rejected: number;
                                cancelled: number;
                            };
                            results: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                } | null;
                                attemptIds: string[];
                                mode: "individual" | "pairwise";
                                origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                                status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                                grader: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                answers: {
                                    criterionId: string;
                                    value: string | number | boolean | null;
                                    abstain: boolean;
                                    note: string;
                                    strength?: "moderate" | "slight" | "strong" | undefined;
                                }[];
                            }[];
                            contentHash: string;
                        };
                        candidate: {
                            schemaVersion: "openpond.humanResultView.v1";
                            executionId: string;
                            executionHash: string;
                            selection: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            }[];
                            coverage: {
                                pending: number;
                                submitted: number;
                                accepted: number;
                                rejected: number;
                                cancelled: number;
                            };
                            results: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                } | null;
                                attemptIds: string[];
                                mode: "individual" | "pairwise";
                                origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                                status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                                grader: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                answers: {
                                    criterionId: string;
                                    value: string | number | boolean | null;
                                    abstain: boolean;
                                    note: string;
                                    strength?: "moderate" | "slight" | "strong" | undefined;
                                }[];
                            }[];
                            contentHash: string;
                        };
                    };
                    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;
                        };
                    };
                    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;
                        };
                    };
                    contentHash: string;
                } | undefined;
            } | null;
            adoptionIntent: {
                operationId: string;
                expectedOwnerRevision: number;
                frozenHash: string;
                humanProjection?: {
                    schemaVersion: "openpond.humanComparisonProjection.v1";
                    teamId: string;
                    projectId: string;
                    selections: {
                        rules: ({
                            feedbackKey: string;
                            criterionId: string;
                            kind: "normalized_score";
                            minimum: number;
                            maximum: number;
                            passThreshold?: number | undefined;
                        } | {
                            feedbackKey: string;
                            criterionId: string;
                            kind: "boolean";
                        } | {
                            feedbackKey: string;
                            criterionId: string;
                            kind: "category";
                        } | {
                            feedbackKey: string;
                            criterionId: string;
                            kind: "preference_score";
                            tieScore: number | null;
                        })[];
                        baseline: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            resultHash: string;
                            reviews: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                            }[];
                        };
                        candidate: {
                            execution: {
                                id: string;
                                contentHash: string;
                            };
                            resultHash: string;
                            reviews: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                            }[];
                        };
                    };
                    original: {
                        baseline: {
                            id: string;
                            manifestHash: string;
                            resultHash: string;
                        };
                        candidate: {
                            id: string;
                            manifestHash: string;
                            resultHash: string;
                        };
                    };
                    humanResults: {
                        baseline: {
                            schemaVersion: "openpond.humanResultView.v1";
                            executionId: string;
                            executionHash: string;
                            selection: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            }[];
                            coverage: {
                                pending: number;
                                submitted: number;
                                accepted: number;
                                rejected: number;
                                cancelled: number;
                            };
                            results: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                } | null;
                                attemptIds: string[];
                                mode: "individual" | "pairwise";
                                origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                                status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                                grader: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                answers: {
                                    criterionId: string;
                                    value: string | number | boolean | null;
                                    abstain: boolean;
                                    note: string;
                                    strength?: "moderate" | "slight" | "strong" | undefined;
                                }[];
                            }[];
                            contentHash: string;
                        };
                        candidate: {
                            schemaVersion: "openpond.humanResultView.v1";
                            executionId: string;
                            executionHash: string;
                            selection: {
                                id: string;
                                revision: number;
                                contentHash: string;
                            }[];
                            coverage: {
                                pending: number;
                                submitted: number;
                                accepted: number;
                                rejected: number;
                                cancelled: number;
                            };
                            results: {
                                review: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                decision: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                } | null;
                                attemptIds: string[];
                                mode: "individual" | "pairwise";
                                origin: "hosted_retained" | "native_local" | "owner_attested_local" | "recorded_evidence";
                                status: "accepted" | "cancelled" | "pending" | "rejected" | "submitted";
                                grader: {
                                    id: string;
                                    revision: number;
                                    contentHash: string;
                                };
                                answers: {
                                    criterionId: string;
                                    value: string | number | boolean | null;
                                    abstain: boolean;
                                    note: string;
                                    strength?: "moderate" | "slight" | "strong" | undefined;
                                }[];
                            }[];
                            contentHash: string;
                        };
                    };
                    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;
                        };
                    };
                    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;
                        };
                    };
                    contentHash: string;
                } | undefined;
            } | null;
            acceptance: {
                id: string;
                contentHash: string;
            } | null;
            rollback: {
                id: string;
                contentHash: string;
            } | null;
            error: string | null;
            createdAt: string;
            updatedAt: string;
            contentHash: string;
        }[];
        nextCursor: string | null;
    }>;
}
//# sourceMappingURL=experiment-improvement-client.d.ts.map