def invocations = withConnection {
            action(new FetchIncludedBuildInvocations()).run()
        }
        def includedTask = invocations[0].tasks[0]
        def includedSelector = invocations[0].taskSelectors[0]

        when:
        withBuild { BuildLauncher launcher ->
            launcher.forLaunchables(includedSelector)
        }

        then:
        thrown(BuildException)

        when:

import org.gradle.api.specs.Spec;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.util.Path;

@ServiceScope(Scope.BuildTree.class)
public interface TaskSelector {
    Spec<Task> getFilter(SelectionContext context, ProjectState project, String taskName, boolean selectAllMatching);

    private final BuildTaskSelector taskSelector;
    private final BuildState targetBuild;

    public CommandLineTaskParser(CommandLineTaskConfigurer commandLineTaskConfigurer, BuildTaskSelector taskSelector, BuildState targetBuild) {
        this.taskConfigurer = commandLineTaskConfigurer;
        this.taskSelector = taskSelector;
        this.targetBuild = targetBuild;
    }

    }

    @Provides
    protected TaskSelector createTaskSelector(ProjectConfigurer projectConfigurer, ObjectFactory objectFactory) {
        return objectFactory.newInstance(DefaultTaskSelector.class, new TaskNameResolver(), projectConfigurer);
    }

    @Provides

@ServiceScope(Scope.BuildTree.class)
public interface BuildTreeWorkController {

    /**
     * Schedules and runs requested tasks based on the provided {@code taskSelector}.
     */
    ExecutionResult<Void> scheduleAndRunRequestedTasks(@Nullable EntryTaskSelector taskSelector);

) : BuildTreeWorkController {

    override fun scheduleAndRunRequestedTasks(taskSelector: EntryTaskSelector?): ExecutionResult<Void> {
        return taskGraph.withNewWorkGraph { graph: BuildTreeWorkGraph ->
            val finalizedGraph: BuildTreeWorkGraph.FinalizedGraph = workPreparer.scheduleRequestedTasks(graph, taskSelector)
            workExecutor.execute(finalizedGraph)
        }
    }

    private val startParameter: ConfigurationCacheStartParameter,
) : BuildTreeWorkController {

    override fun scheduleAndRunRequestedTasks(taskSelector: EntryTaskSelector?): ExecutionResult<Void> {
        val scheduleTaskSelectorPostProcessing: BuildTreeWorkGraphBuilder? = taskSelector?.let { selector ->
            { rootBuildState ->
                addFinalization(rootBuildState, selector::postProcessExecutionPlan)
            }

    }

    private void assertTaskFailureDescription(String taskSelector) {
        if (GradleContextualExecuter.configCache) {
            failureDescriptionContains("Configuration cache state could not be cached:")
            failureDescriptionContains(taskSelector)
        } else {
            def description = "Execution failed for task '${taskSelector}'."
            failure.assertHasDescription(description)
        }

        return new OptionReader();
    }

    @Provides
    CommandLineTaskParser createCommandLineTaskParser(OptionReader optionReader, BuildTaskSelector taskSelector, BuildState build) {
        return new CommandLineTaskParser(new CommandLineTaskConfigurer(optionReader), taskSelector, build);
    }

    @Provides
    BuildWorkExecutor createBuildExecuter(StyledTextOutputFactory textOutputFactory, BuildOperationRunner buildOperationRunner) {

import javax.annotation.Nonnull;
import javax.inject.Inject;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

public class DefaultTaskSelector implements TaskSelector {
    private static final Logger LOGGER = Logging.getLogger(DefaultTaskSelector.class);

    private final TaskNameResolver taskNameResolver;
    private final ProjectConfigurer configurer;

    @Inject