*/
        MaybeWorkReadyToStart,
        /**
         * No work is ready to start, but there are items still queued to start. The worker thread should wait for a change and check again.
         */
        NoWorkReadyToStart,
        /**
         * All work has started (but not necessarily finished) and there are no further items to start. The worker thread should finish polling this source.

                }
            }
            if (nothingMoreToStart()) {
                return WorkSource.State.NoMoreWorkToStart;
            } else {
                return WorkSource.State.NoWorkReadyToStart;
            }
        }

        public WorkSource.Selection<WorkItem> selectNext() {
            coordinationService.assertHasStateLock();
            Iterator<PlanDetails> iterator = queues.iterator();

                finalizedPlan.finishedExecuting(node, null)
            }
            assert finalizedPlan.executionState() == WorkSource.State.NoWorkReadyToStart
            assert finalizedPlan.selectNext().noWorkReadyToStart
            assert finalizedPlan.executionState() == WorkSource.State.NoWorkReadyToStart
        }
    }

    void assertNoMoreWorkToStartButNotAllComplete(boolean needToSelect = false) {

            return State.NoMoreWorkToStart;
        } else if (!readyNodes.isEmpty() && maybeNodesSelectable) {
            return State.MaybeWorkReadyToStart;
        } else {
            return State.NoWorkReadyToStart;
        }
    }

    @Override
    public Diagnostics healthDiagnostics() {
        lockCoordinator.assertHasStateLock();

        List<String> ordinalGroups = new ArrayList<>();

                def selection = finalizedPlan.selectNext()
                if (selection.noMoreWorkToStart) {
                    break
                }
                assert !selection.noWorkReadyToStart // There should always be a node ready to start when executing sequentially
                def nextNode = selection.item
                assert !nextNode.isComplete()
                nodes << nextNode