public void addFilter(Spec<Task> filter) {
            getOwnedPlan().addFilter(filter);
        }

        @Override
        public void addFinalization(BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization) {
            getOwnedPlan().addFinalization(finalization);
        }

        private BuildWorkPlan getOwnedPlan() {
            assertIsOwner();
            createPlan();

     */
    void onComplete(Consumer<LocalTaskNode> handler);

    void addFilter(Spec<Task> filter);

    void addFinalization(BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization);

    /**
     * Adds a task filter to this work graph.
     */
    void addFilter(Spec<Task> filter);

    /**
     * Adds a finalization step to this work graph.
     */
    void addFinalization(BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization);

    /**
     * Finalize the work graph for execution, after all work has been scheduled. This method should not schedule any additional work.

        val scheduleTaskSelectorPostProcessing: BuildTreeWorkGraphBuilder? = taskSelector?.let { selector ->
            { rootBuildState ->
                addFinalization(rootBuildState, selector::postProcessExecutionPlan)
            }
        }
        val executionResult = workGraph.withNewWorkGraph { graph ->
            val result = cache.loadOrScheduleRequestedTasks(

         */
        void addFilter(BuildState target, Spec<Task> filter);

        /**
         * Adds a {@link ExecutionPlan} finalization step to the given build.
         */
        void addFinalization(BuildState target, BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization);
    }

        targetBuildController.prepareToScheduleTasks();
        return graph.scheduleWork(graphBuilder -> {
            if (selector != null) {
                graphBuilder.addFinalization(targetBuild, selector::postProcessExecutionPlan);
            }
            graphBuilder.withWorkGraph(targetBuild, builder -> builder.addRequestedTasks(selector));
        });
    }

            buildControllerOf(target).addFilter(filter);
        }

        @Override
        public void addFinalization(BuildState target, BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization) {
            buildControllerOf(target).addFinalization(finalization);
        }

        @Override

        assertInState(State.DiscoveringTasks);
        workGraph.addFilter(filter);
    }

    @Override
    public void addFinalization(BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization) {
        assertInState(State.DiscoveringTasks);
        workGraph.addFinalization(finalization);
    }

    @Override
    public boolean scheduleQueuedTasks() {
        assertInState(State.DiscoveringTasks);

    /**
     * Adds a filter to the work graph of this build.
     */
    void addFilter(Spec<Task> filter);

    /**
     * Adds a finalization step to the work graph of this build.
     */
    void addFinalization(BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization);

    /**
     * Queues the given task for execution. Does not schedule the task, use {@link #scheduleQueuedTasks()} for this.
     */

            plan.close();
        }

        @Override
        public void addFilter(Spec<Task> filter) {
            plan.addFilter(filter);
        }

        @Override
        public void addFinalization(BiConsumer<EntryTaskSelector.Context, QueryableExecutionPlan> finalization) {
            finalizations.add(finalization);
        }

        @Override