default void postProcessExecutionPlan(Context context, QueryableExecutionPlan plan) {
    }

    interface Context {
        TaskSelection getSelection(String taskPath);

        GradleInternal getGradle();
    }

        }

        @Override
        public TaskSelection getSelection(String taskPath) {
            return taskSelector.resolveTaskName(taskPath);
        }

        @Override
        public GradleInternal getGradle() {
            return gradle;
        }
    }

        } else {
            return PluginRequests.of(createDevelocityPluginRequest());
        }
    }

    private static boolean shouldApplyGradleEnterprisePlugin(Settings settings) {
        Gradle gradle = settings.getGradle();
        StartParameter startParameter = gradle.getStartParameter();
        return startParameter.isBuildScan() && gradle.getParent() == null;
    }

        return new TaskIdentity<>(
            type,
            name,
            project.projectPath(name),
            project.identityPath(name),
            project.getGradle().getIdentityPath(),
            uniqueId
        );
    }

        this.action = action;
        this.gradle = gradle;
        this.failure = failure;
    }

    @Nullable
    public Gradle getGradle() {
        return gradle;
    }

    @Nullable
    public Throwable getFailure() {
        return failure;
    }

    /**
     * The action performed by this build. Either `Build` or `Configure`.

        """
        file('build.gradle') << """
            plugins { id 'counting-service-plugin' version '1.0' }

            def altServiceProvider = project.getGradle().getSharedServices().registerIfAbsent(
                "counter",
                CountingService.class,
                (spec) -> {}
            );

            tasks.register('count', CountingTask) {

        this.state = controllerFactory.newController(Describables.of("state of", targetBuild().getDisplayName()), State.Configure);
    }

    @Override
    public GradleInternal getGradle() {
        // Should not ignore other threads, however it is currently possible for this to be queried by tasks at execution time (that is, when another thread is

    DefaultProjectDescriptor getDefaultProject();

    void setDefaultProject(DefaultProjectDescriptor defaultProject);

    @Override
    GradleInternal getGradle();

    List<IncludedBuildSpec> getIncludedBuilds();

    /**
     * The parent scope for this and all settings objects.
     *
     * Gradle runtime.
     */
    ClassLoaderScope getBaseClassLoaderScope();

            import ${Settings.name};
            import ${Plugin.name};

            public class PluginImpl implements Plugin<Settings> {
                public void apply(Settings settings) {
                    settings.getGradle().rootProject(p -> {
                        p.getTasks().register("greeting", task -> {
                            task.doLast(s -> System.out.println("Hello world"));
                        });
                    });

        return buildAction.apply(buildTreeLifecycleController);
    }

    @Override
    public Path calculateIdentityPathForProject(Path projectPath) {
        return getBuildController().getGradle().getIdentityPath().append(projectPath);
    }

    @Override
    public File getBuildRootDir() {
        return buildDefinition.getBuildRootDir();
    }

    @Override