requiresNotEc2Agent()
        requiresNotSharedHost()
    }

    features {
        publishBuildStatusToGithub(model)
    }

    dependencies {
        // If SanityCheck fails, Gradleception will definitely fail because the last build step is also sanityCheck
        dependsOn(RelativeId(SanityCheck.buildTypeId(model)))
    }

    /*
     To avoid unnecessary rerun, what we do here is a bit complicated:

A session runs the build one or more times.
For example, when continuous build is enabled, the session may run the build many times, but when it is disabled, the session will run the build once only.

The build session state is managed by the `BuildSessionState` class.
An instance is created at the start of a Gradle invocation and discarded at the end of that invocation.

import org.gradle.internal.deprecation.DeprecationLogger
import java.io.File


/**
 * Facilitates the implementation of the [Gradle] interface by delegation via subclassing.
 */
@Deprecated("Will be removed in Gradle 9.0")
abstract class GradleDelegate : Gradle {

    init {
        @Suppress("DEPRECATION")
        if (!org.gradle.kotlin.dsl.InitScriptApi::class.java.isAssignableFrom(this::class.java)) {

        // and that usage can be benign. This is especially important when the currently running task is
        // marked as `notCompatibleWithConfigurationCache` - attributing the error to `task` will cause
        // the build to fail when it really shouldn't.
        val contextTask = runningTask ?: task
        val isExecutingOtherTask = contextTask != task
        problemsListenerFor(contextTask).onProblem(

        }

        override fun toRestoring(): Restoring {
            // Restoration must consider properties that was overridden after store.
            // When property was loaded and stored then loaded value will be presented for execution time after restore.
            // This is a wrong behavior if property was overridden. Execution time must see overridden value instead of restored one.

        assertEquals(123, runtimeInstanceFromResult.myLambdaReceiver.x)
        assertEquals("test", runtimeInstanceFromResult.myLambdaReceiver.y)
    }

    // don't make this private, will produce failures on Java 8 (due to https://youtrack.jetbrains.com/issue/KT-37660)
    val runtimeCustomAccessors = object : RuntimeCustomAccessors {

            </p>
            ${writeFilterPreset(project)}
""".stripIndent()

        it.renderer.set(EnrichedReportRenderer.class)
    } as Action)

            params("${providedBy.size + 1}")
        }
    }

    /**
     * For all modules providing a capability, always use the preferred module, even if there's no conflict.
     * In other words, will forcefully upgrade all modules providing a capability to a selected module.
     *
     * @param to the preferred module
     */
    private
    fun ConfigurationContainer.forceUpgrade(to: String, version: String) = all {

If an exception implements this interface, Gradle will not display the `--stacktrace` option.

Another more targeted interface is `CompilationFailedIndicator`.
This interface is used to indicate that the exception is caused by a compilation failure. 

        val gradleUserHomeDir: File,
        val jvm: String,
        val startParameterProperties: Map<String, Any?>,
        /**
         * Whether the undeclared inputs accessed while serializing the task graph will be
         * excluded from input tracking. This is a temporary opt-out flag after a change
         * was made in that behavior.
         */
        val ignoreInputsInConfigurationCacheTaskGraphWriting: Boolean,
        /**