gradle.getOwner().getProjects().withMutableStateOfAllProjects(() -> {
            buildTaskScheduler.scheduleRequestedTasks(gradle, selector, plan);

            if (buildModelParameters.isConfigureOnDemand() && gradle.isRootBuild()) {
                new ProjectsEvaluatedNotifier(buildOperationRunner).notify(gradle);
            }
        });
    }

package org.gradle.internal.cc.impl

import org.gradle.api.internal.GradleInternal
import org.gradle.execution.plan.ScheduledWork
import org.gradle.internal.build.BuildState


interface VintageGradleBuild {
    val isRootBuild: Boolean
    val state: BuildState
    val gradle: GradleInternal
    val hasScheduledWork: Boolean
    val scheduledWork: ScheduledWork

        this.buildOperationRunner = buildOperationRunner;
    }

    @Override
    public void prepareProjects(GradleInternal gradle) {
        if (!buildModelParameters.isConfigureOnDemand() || !gradle.isRootBuild()) {
            projectConfigurer.configureHierarchy(gradle.getRootProject());
            new ProjectsEvaluatedNotifier(buildOperationRunner).notify(gradle);
        }
    }

        public BuildOperationDescriptor.Builder description() {
            BuildOperationDescriptor.Builder builder = BuildOperationDescriptor.displayName(gradle.contextualize("Configure build"));
            if (gradle.isRootBuild()) {
                builder.metadata(BuildOperationCategory.CONFIGURE_ROOT_BUILD);
            } else {
                builder.metadata(BuildOperationCategory.CONFIGURE_BUILD);
            }

        public BuildOperationDescriptor.Builder description() {
            BuildOperationDescriptor.Builder builder = BuildOperationDescriptor.displayName(gradle.contextualize("Run tasks"));
            if (gradle.isRootBuild()) {
                long buildStartTime = gradle.getServices().get(BuildRequestMetaData.class).getStartTime();
                builder.details(new RunRootBuildWorkBuildOperationType.Details(buildStartTime));
            }

     * This should never happen due to the auto apply behavior.
     * It's only here as a kind of safeguard or fallback.
     */
    public void registerMissingPluginWarning(GradleInternal gradle) {
        if (gradle.isRootBuild()) {
            StartParameter startParameter = gradle.getStartParameter();
            boolean requested = !startParameter.isNoBuildScan() && startParameter.isBuildScan();
            if (requested) {

        CacheConfigurationsInternal cacheConfigurations = objectFactory.newInstance(DefaultCacheConfigurations.class, legacyCacheCleanupEnablement);
        if (gradleInternal.isRootBuild()) {
            cacheConfigurations.synchronize(persistentCacheConfigurations);
            persistentCacheConfigurations.setCleanupHasBeenConfigured(false);
        }
        return cacheConfigurations;
    }

            it.usingInitScript(this.initScript)
        }
    }

    static String injectNotificationListenerBuildLogic() {
        """
            rootProject {
                if(gradle.isRootBuild()) {
                    def listener = new BuildOperationNotificationsEvaluationListener()
                    def registrar = project.services.get($BuildOperationNotificationListenerRegistrar.name)

     */
    @Override
    ProjectInternal getRootProject() throws IllegalStateException;

    @Override
    @Nullable
    GradleInternal getParent();

    GradleInternal getRoot();

    boolean isRootBuild();

    /**
     * Returns the {@link BuildState} that manages the state of this instance.
     */
    BuildState getOwner();

    /**
     * {@inheritDoc}
     */
    @Override

        gradle.services.getFactory(serviceType)

    private
    class DefaultVintageGradleBuild(override val state: BuildState) : VintageGradleBuild {
        override val isRootBuild: Boolean
            get() = state is RootBuildState

        override val gradle: GradleInternal
            get() = state.mutableModel

        override val hasScheduledWork: Boolean