openlanes 3.0.1 → 3.1.0

data/lib/openlanes/plans/pull_request_machine.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "aasm"
+
+module OpenLanes
+  module Plans
+    # The state machine for one pull request (decision P2).
+    #
+    # A plan's state is the emoji in its folder name; a pull request's is the
+    # {ReviewLabel} it carries on GitHub. A plan may have several pull
+    # requests, each somewhere else in review, so the two machines are kept
+    # apart: {StateMachine} moves folders, this one says which label may
+    # follow which. Like {StateMachine}, it keeps no state of its own. It is
+    # read off the labels and the row's GitHub state, and the caller makes
+    # the change on GitHub through {Vcs::Review} or {Vcs::GitHub}.
+    #
+    # `merged` and `closed` are not labels. They are GitHub's own states,
+    # and they outrank any label still on the pull request.
+    class PullRequestMachine
+      include AASM
+
+      # Raised when a move is refused, naming both ends.
+      class Refused < Error; end
+
+      # Label name => state key: `ready-to-merge` is `:ready_to_merge`.
+      #
+      # @param name [String]
+      # @return [Symbol]
+      def self.key_for(name) = name.to_s.tr("-", "_").to_sym
+
+      # The state with no label on it yet: opened before the publisher
+      # labelled it, or by a person.
+      UNLABELLED = :unlabelled
+
+      aasm do
+        state UNLABELLED, initial: true
+        ReviewLabel::ALL.each { |label| state PullRequestMachine.key_for(label.name) }
+        state :merged
+        state :closed
+
+        event :submit do
+          transitions from: %i[unlabelled review_rejected review_vulnerability], to: :ready_for_review
+        end
+
+        event :start_review do
+          transitions from: %i[unlabelled ready_for_review], to: :review_in_progress
+        end
+
+        # The reviewers' verdicts, and chewie's rejection after them. A
+        # rejection also reaches back from `ready-to-merge` and
+        # `merge-manually`: a pull request that no longer rebases onto
+        # `main` after its sibling merged goes back to the builders (P5), and
+        # a person may reject one they were asked to merge.
+        event :reject do
+          transitions from: %i[review_in_progress review_ok_not_perfect review_approved ready_to_merge merge_manually],
+            to: :review_rejected
+        end
+
+        event :flag_vulnerability do
+          transitions from: %i[review_in_progress review_rejected], to: :review_vulnerability
+        end
+
+        event :pass_with_doubts do
+          transitions from: %i[review_in_progress], to: :review_ok_not_perfect
+        end
+
+        event :approve do
+          transitions from: %i[review_in_progress], to: :review_approved
+        end
+
+        # chewie verified it, CI is green and the coverage gate holds.
+        event :ready do
+          transitions from: %i[review_ok_not_perfect review_approved], to: :ready_to_merge
+        end
+
+        # palpatine's two verdicts, as the engine acted on them. Only a
+        # `ready-to-merge` pull request is ruled on.
+        event :merge_automatically do
+          transitions from: %i[ready_to_merge], to: :auto_merged
+        end
+
+        event :leave_for_a_person do
+          transitions from: %i[ready_to_merge], to: :merge_manually
+        end
+
+        # GitHub's own states. A person may merge or close at any point; an
+        # `auto-merged` pull request is merged already.
+        event :merged do
+          transitions from: ReviewLabel::ALL.map { PullRequestMachine.key_for(it.name) } + [UNLABELLED], to: :merged
+        end
+
+        event :close do
+          transitions from: (ReviewLabel::ALL.map { PullRequestMachine.key_for(it.name) } - %i[auto_merged]) + [UNLABELLED],
+            to: :closed
+        end
+      end
+
+      # Where a pull request stands, from its row and its labels. GitHub's
+      # merged or closed wins over any label; among labels, the one furthest
+      # along {ReviewLabel::ALL} wins, since a stale verdict left beside a
+      # newer one is the older of the two.
+      #
+      # @param pull [PullRequest] its row in `pull-requests.md`
+      # @param labels [Array<String>] its labels on GitHub now
+      # @return [Symbol]
+      def self.state_of(pull, labels)
+        return :merged if pull.merged?
+        return :closed unless pull.open?
+
+        label = ReviewLabel::ALL.rfind { labels.include?(it.name) }
+        label ? key_for(label.name) : UNLABELLED
+      end
+
+      # @param pull [PullRequest]
+      # @param labels [Array<String>]
+      def initialize(pull, labels)
+        @pull = pull
+        @key = self.class.state_of(pull, labels)
+      end
+
+      # @return [PullRequest]
+      attr_reader :pull
+
+      # @return [Symbol] the state right now
+      attr_reader :key
+
+      # AASM keeps state in a column; this one is read off GitHub, and a move
+      # is only ever asked about, never stored here.
+      #
+      # @return [Symbol]
+      def aasm_read_state(_name = :default) = @key
+
+      # @return [Boolean]
+      def aasm_write_state(new_state, name = :default) = aasm_write_state_without_persistence(new_state, name)
+
+      # @return [Boolean]
+      def aasm_write_state_without_persistence(new_state, _name = :default)
+        @key = new_state
+        true
+      end
+
+      # @return [Boolean] whether palpatine's verdict has been acted on (P2)
+      def complete? = %i[auto_merged merge_manually].include?(key)
+
+      # @param event [Symbol]
+      # @return [Boolean] whether +event+ may fire from here
+      def may?(event) = aasm.may_fire_event?(event)
+
+      # Take one step, so the caller learns the move is legal before it
+      # changes anything on GitHub.
+      #
+      # @param event [Symbol]
+      # @return [Symbol] the state now occupied
+      # @raise [Refused] when the move is not in the topology
+      def fire!(event)
+        raise Refused, "PR ##{pull.number.to_s.delete("#")} is #{key}; #{event} does not apply" unless may?(event)
+
+        aasm.fire!(event)
+        key
+      end
+    end
+  end
+end

data/lib/openlanes/plans/review_label.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Plans
+    # A label that says where a pull request stands in review (decision R3,
+    # which replaced M3's set).
+    #
+    # A pull request carries at most one of these at a time; a new verdict
+    # replaces the previous one. The one exception is {VULNERABILITY}, which
+    # sits beside {REJECTED}. This file is the only place under `lib/` that
+    # spells a label's name, so the CLI help, the docs table, the `gh` calls
+    # and the label sync cannot drift apart.
+    ReviewLabel = Data.define(:name, :colour, :meaning, :passing) do
+      alias_method :passing?, :passing
+
+      # @return [String] the name, so a label interpolates as itself
+      def to_s = name
+    end
+
+    class ReviewLabel
+      ALL = [
+        new(name: "ready-for-review",
+          colour: "c2e0c6",
+          meaning: "luke and rey are done; the PR waits for a free review slot",
+          passing: false),
+        new(name: "review-in-progress", colour: "FFBE20", meaning: "the reviewers have started", passing: false),
+        new(name: "review-rejected", colour: "F90000", meaning: "at least one ⛔️ or 💣", passing: false),
+        new(name: "review-vulnerability",
+          colour: "FF0050",
+          meaning: "at least one 💣; sits beside review-rejected",
+          passing: false),
+        new(name: "review-ok-not-perfect", colour: "E8E890", meaning: "no ⛔️ or 💣, but more 🤔 than review.max_hmm (5 by default)", passing: true),
+        new(name: "review-approved", colour: "109a10", meaning: "no ⛔️ or 💣, few 🤔", passing: true),
+        new(name: "ready-to-merge",
+          colour: "5319e7",
+          meaning: "chewie-verifier verified it and its E2E tests pass",
+          passing: true),
+        # palpatine's two verdicts, as the engine acted on them (P2).
+        new(name: "auto-merged",
+          colour: "953384",
+          meaning: "palpatine-risk-assessor judged it safe and the engine merged it",
+          passing: true),
+        new(name: "merge-manually",
+          colour: "0e8a16",
+          meaning: "palpatine-risk-assessor, or merge.by: human, left it for a person to merge",
+          passing: true)
+      ].freeze
+
+      # @param name [String]
+      # @return [ReviewLabel]
+      def self.named(name) = ALL.find { |l| l.name == name }
+
+      # The label the publisher puts on a pull request it has just opened.
+      INITIAL = named("ready-for-review")
+
+      # The verdict accepted even while CI is red.
+      REJECTED = named("review-rejected")
+
+      # The one label that sits beside another: always next to {REJECTED},
+      # since a 💣 is also a rejection. Accepted while CI is red for the same
+      # reason {REJECTED} is.
+      VULNERABILITY = named("review-vulnerability")
+
+      # The verdict for a review with no ⛔️ or 💣 but too many 🤔.
+      OK_NOT_PERFECT = named("review-ok-not-perfect")
+
+      # The verdict for everything else.
+      APPROVED = named("review-approved")
+
+      # chewie-verifier's label, and the one the coverage gate withholds.
+      READY_TO_MERGE = named("ready-to-merge")
+
+      # The engine merged it on palpatine's `auto`.
+      AUTO_MERGED = named("auto-merged")
+
+      # palpatine said `manual`, or `merge.by: human` overrode its `auto`.
+      MERGE_MANUALLY = named("merge-manually")
+
+      # Either verdict: the pull request is complete (P2).
+      COMPLETE = [AUTO_MERGED, MERGE_MANUALLY].freeze
+
+      # Not a verdict, and so not in {ALL}: {Vcs::LabelSync} never creates or
+      # recolours it. Its presence on a repository is the one sign that
+      # {Vcs::LabelMigration} has finished there. The colour of
+      # `ready-to-merge` could not be that sign: an earlier release recoloured
+      # it without moving a single pull request.
+      MIGRATED = new(name: "openlanes-r3-labels",
+        colour: "ededed",
+        meaning: "openlanes moved this repository's open PRs from M3's review labels to R3's",
+        passing: false)
+
+      # M3's names for verdicts R3 kept under another name: `review-passed`
+      # is R3's {OK_NOT_PERFECT}, and chewie's `ok-to-merge` is R3's
+      # {READY_TO_MERGE}.
+      RENAMED = { "review-passed" => OK_NOT_PERFECT, "ok-to-merge" => READY_TO_MERGE }.freeze
+
+      # M3's verdicts that R3 dropped. Nothing sets them any more, but pull
+      # requests labelled before R3 still carry them, so every new verdict
+      # takes them off: otherwise #62's `review-passed` would sit beside its
+      # next verdict, two at once. LabelSync never deletes them from the
+      # repository; that stays a person's call.
+      RETIRED = RENAMED.keys.freeze
+
+      class << self
+        # @return [Array<String>] every label name, in R3 order
+        def names = ALL.map(&:name)
+
+        # @return [Array<String>] every name a verdict replaces: R3's and {RETIRED}
+        def known = names + RETIRED
+
+        # @return [Array<ReviewLabel>] the verdicts refused while CI is red
+        def passing = ALL.select(&:passing?)
+
+        # The labels a new one takes off the pull request. Everything else in
+        # the set, {RETIRED} included, except that setting {VULNERABILITY} leaves {REJECTED} where
+        # it is, and setting {REJECTED} leaves {VULNERABILITY}: the two are
+        # set as a pair, one call each, in either order.
+        #
+        # @param label [ReviewLabel]
+        # @return [Array<String>]
+        def displaced_by(label)
+          kept = [label, *(PAIR if PAIR.include?(label))].map(&:name)
+          known - kept
+        end
+
+        # @param name [String, ReviewLabel]
+        # @return [ReviewLabel]
+        # @raise [OpenLanes::Error] naming the valid labels
+        def fetch(name)
+          named(name.to_s) ||
+            raise(Error, "unknown review label #{name.to_s.inspect}; one of: #{names.join(", ")}")
+        end
+      end
+
+      # The two labels that may sit together.
+      PAIR = [REJECTED, VULNERABILITY].freeze
+    end
+  end
+end

data/lib/openlanes/plans/spec.rb

@@ -20,6 +20,7 @@ module OpenLanes
     #     - `openlanes create` opens an editor and writes no draft
     #   how-to-verify:
     #     - bundle exec rspec spec/openlanes/cli/create_spec.rb
+    #   depends_on: ["034.00"]   # plans that must be ✅ before this one starts
     #   ---
     #
     # The body is the specification; this is how it should be worked. A value
@@ -49,6 +50,13 @@ module OpenLanes
     # @!attribute [r] how_to_verify
     #   @return [Array<String>] the author's `how-to-verify`: the commands or
     #     checks that show it is.
+    # @!attribute [r] depends_on
+    #   @return [Array<String>, nil] canonical `NNN.MM` ordinals of the plans
+    #     this one waits for. nil when the key is absent ("not checked yet"),
+    #     which is not the same as `[]` ("checked, none").
+    # @!attribute [r] how_to_test
+    #   @return [Array<String>] the items under {HOW_TO_TELL} in the body, or
+    #     {#how_to_verify} when the spec has no such section (until plan 007).
     # @!attribute [r] problems
     #   @return [Array<String>] what was ignored, and why
     Spec = Data.define(:lane,
@@ -59,9 +67,11 @@ module OpenLanes
       :requirements,
       :completed_when,
       :how_to_verify,
+      :depends_on,
+      :how_to_test,
       :problems) do
       def initialize(lane: :full, frontend: nil, depth: nil, phases: {}, suggestions: [], requirements: [],
-        completed_when: [], how_to_verify: [], problems: [])
+        completed_when: [], how_to_verify: [], how_to_test: [], depends_on: nil, problems: [])
         super
       end
 
@@ -106,8 +116,32 @@ module OpenLanes
       COMPLETED_WHEN_KEY = "task-completed-when"
       HOW_TO_VERIFY_KEY = "how-to-verify"
 
+      # The plans this one waits for. Quoted canonical ordinals only: YAML
+      # reads a bare `[034]` as octal 28, a silent wrong answer.
+      DEPENDS_ON_KEY = "depends_on"
+
+      # Where `how-to-verify:` lives now (decision M10): a section of the
+      # spec's body, written by its author like every other, rather than a
+      # key in its frontmatter. `resync dirs` moves the key's items here.
+      HOW_TO_VERIFY_HEADING = "## How to tell it's working?"
+
+      # The same section, by the name the publisher refuses a pull request
+      # without: plan.md must carry its copy.
+      HOW_TO_TELL = HOW_TO_VERIFY_HEADING
+
+      # The heading on a line of its own. An author's editor may type a curly apostrophe (`it’s`) or leave the
+      # question mark off; either must still find the section, not drop the
+      # checks without a word.
+      HOW_TO_VERIFY_LINE = /^##[ \t]+how to tell it['‘’]s working\??[ \t]*$/i
+
       FILENAME = "spec.md"
 
+      # A list item under the heading; +marker+ ends at its content column.
+      LIST_ITEM = /\A(?<marker>\s*(?:[-*]|\d+\.)\s+)(?<text>.+)/
+
+      # The opening of a fenced code block, and its fence.
+      FENCE = /\A(\s*)(`{3,}|~{3,})/
+
       class << self
         # @param subject [#read]
         # @return [OpenLanes::Plans::Spec]
@@ -120,15 +154,68 @@ module OpenLanes
           File.file?(path) ? parse(File.read(path, encoding: "UTF-8")) : new
         end
 
+        # The spec's first paragraph of prose, which the dashboard shows when a
+        # person hovers a plan's title: headings, comments, lists, quotes and
+        # code are passed over, so a spec that opens with `## Problem
+        # statement` answers with the problem itself.
+        #
+        # @param text [String] a whole spec.md
+        # @param limit [Integer] characters kept, the rest cut at a word
+        # @return [String] "" when the spec has no prose paragraph
+        def summary(text, limit: 600)
+          _, body = Frontmatter.split(text)
+          paragraph = body.to_s.gsub(/<!--.*?-->/m, "").split(/\n\s*\n/).map(&:strip).find do |block|
+            !block.empty? && !block.match?(/\A(?:#|>|[-*+] |\d+\. |```|~~~|\||<)/)
+          end.to_s.gsub(/\s*\n\s*/, " ")
+          paragraph.length > limit ? "#{paragraph[0, limit].sub(/\s+\S*\z/, "")}…" : paragraph
+        rescue Psych::Exception
+          ""
+        end
+
         # @param text [String] a whole spec.md
         # @return [OpenLanes::Plans::Spec]
         def parse(text)
-          meta, = Frontmatter.split(text)
-          from(meta)
+          meta, body = Frontmatter.split(text)
+          spec = from(meta)
+          told = section_items(body.to_s)
+          checks = (spec.how_to_verify + told).uniq
+          # how_to_test prefers the body's own section; the frontmatter key
+          # stands in until plan 007 migrates old specs.
+          spec.with(how_to_verify: checks, how_to_test: told.empty? ? spec.how_to_verify : told)
         rescue Psych::Exception => e
           new(problems: ["spec.md frontmatter is not valid YAML (#{e.message.lines.first.strip})"])
         end
 
+        # Move a `how-to-verify:` frontmatter key into the body (M10): its
+        # items are appended to `## How to tell it's working?`, which is added
+        # at the end when the spec has none. The rest of the frontmatter is
+        # kept as written, comments and all, and a frontmatter left empty is
+        # dropped.
+        #
+        # @param text [String] a whole spec.md
+        # @return [String] +text+ itself when there is no key to move, or no
+        #   way to remove it that leaves the other keys exactly as they were
+        def migrate_how_to_verify(text)
+          match = Frontmatter::PATTERN.match(text) or return text
+          meta, = Frontmatter.split(text)
+          return text unless meta.key?(HOW_TO_VERIFY_KEY)
+
+          front = without_key("#{match[1]}\n", HOW_TO_VERIFY_KEY, meta) or return text
+          items = notes(meta, HOW_TO_VERIFY_KEY, [])
+          head = front.strip.empty? ? "" : "---\n#{front}---\n"
+          "#{head}#{append_checks(match[2], items)}"
+        rescue Psych::Exception
+          text
+        end
+
+        # One check as a Markdown list item. A check written as a YAML block
+        # scalar spans lines; its continuation lines are indented under the
+        # item, so they stay part of it rather than becoming loose prose.
+        #
+        # @param item [String]
+        # @return [String] without a trailing newline
+        def list_item(item) = "- #{item.gsub("\n", "\n  ")}"
+
         # @param meta [Hash]
         # @return [OpenLanes::Plans::Spec]
         def from(meta)
@@ -141,11 +228,140 @@ module OpenLanes
             requirements: notes(meta, REQUIREMENTS_KEY, problems),
             completed_when: notes(meta, COMPLETED_WHEN_KEY, problems),
             how_to_verify: notes(meta, HOW_TO_VERIFY_KEY, problems),
+            depends_on: depends_on(meta, problems),
+            how_to_test: notes(meta, HOW_TO_VERIFY_KEY, []),
             problems:)
         end
 
         private
 
+        # The YAML source of +yaml+ with +key+'s entry cut out, from the
+        # key's line to the end of its value as Psych located them. A regex
+        # over the text took a blank line between list items for the end of
+        # the entry, leaving the later items behind, and never matched a
+        # quoted key at all. The cut is kept only when what is left loads as
+        # the same mapping less that key; anything else (a flow mapping, a key
+        # sharing a line) is not cut.
+        #
+        # @param yaml [String]
+        # @param key [String]
+        # @param meta [Hash] +yaml+, loaded
+        # @return [String, nil]
+        def without_key(yaml, key, meta)
+          root = Psych.parse(yaml)&.root
+          return nil unless root.is_a?(Psych::Nodes::Mapping)
+
+          name, value = root.children.each_slice(2).find { |k, _| k.is_a?(Psych::Nodes::Scalar) && k.value == key }
+          return nil unless name
+
+          stop = value.end_column.zero? ? value.end_line : value.end_line + 1
+          lines = yaml.lines
+          rest = (lines[0...name.start_line] + lines[stop..].to_a).join
+          left, = Frontmatter.split("---\n#{rest}\n---\n")
+          rest if left == meta.except(key)
+        end
+
+        # The checks under `## How to tell it's working?`, in document order,
+        # up to the next heading of the same level. The owner wants how-to-test
+        # as specific and technical as it can be, and prose can be just as
+        # specific as a bullet (2026-10-14, on M10), so prose is a check too
+        # rather than the author's aside that the agents never see:
+        #
+        # - A list item is one check, with its indented continuation lines and
+        #   any fenced block indented under it, blank lines in the fence
+        #   included. Its lines lose the item's indent and keep the rest, so
+        #   a command's own indentation survives.
+        # - A prose paragraph (consecutive non-blank, non-list lines) is one
+        #   check, its lines as written.
+        # - A fenced block not indented under an item joins the prose
+        #   paragraph just before it, or is a check of its own.
+        #
+        # Inside a fence nothing is a list item or a heading, so a
+        # `- not an item` line there stays in the code. {list_item} writes any
+        # of these back as one item, which this reads back unchanged.
+        #
+        # @param body [String]
+        # @return [Array<String>]
+        def section_items(body)
+          start = body =~ HOW_TO_VERIFY_LINE or return []
+          checks = []
+          state = { kind: nil, indent: 0, fence: nil }
+          body[start..].lines.drop(1).each do |line|
+            line = line.chomp
+            if state[:fence]
+              fence_line(checks, state, line)
+            elsif line.start_with?("## ")
+              break
+            else
+              section_line(checks, state, line)
+            end
+          end
+          checks.map(&:strip)
+        end
+
+        # A line inside a fenced block, the closing fence included.
+        def fence_line(checks, state, line)
+          checks[-1] = "#{checks.last}\n#{state[:kind] == :item ? dedent(line, state[:indent]) : line}"
+          fence = state[:fence]
+          state[:fence] = nil if line.strip.match?(/\A#{Regexp.escape(fence[0])}{#{fence.length},}\z/)
+        end
+
+        # A line outside any fence: it opens a fence, an item or a paragraph,
+        # or continues the one it follows.
+        def section_line(checks, state, line)
+          if (fence = line[FENCE, 2])
+            open_fence(checks, state, line, fence)
+          elsif (item = line.match(LIST_ITEM))
+            checks << item[:text]
+            state.merge!(kind: :item, indent: item.end(:marker))
+          elsif line.strip.empty?
+            state[:kind] = :after_prose if state[:kind] == :prose
+          elsif state[:kind] == :item && line.match?(/\A[ \t]/)
+            checks[-1] = "#{checks.last}\n#{dedent(line, state[:indent])}"
+          elsif state[:kind] == :prose
+            checks[-1] = "#{checks.last}\n#{line}"
+          else
+            checks << line
+            state[:kind] = :prose
+          end
+        end
+
+        # An indented fence under an open item belongs to it; any other joins
+        # the paragraph before it, or starts a check of its own.
+        def open_fence(checks, state, line, fence)
+          if state[:kind] == :item && line.match?(/\A[ \t]/)
+            checks[-1] = "#{checks.last}\n#{dedent(line, state[:indent])}"
+          elsif %i[prose after_prose].include?(state[:kind])
+            checks[-1] = "#{checks.last}\n#{line}"
+            state[:kind] = :prose
+          else
+            checks << line
+            state[:kind] = :prose
+          end
+          state[:fence] = fence
+        end
+
+        # +line+ less up to +indent+ leading blanks.
+        def dedent(line, indent) = line.sub(/\A[ \t]{0,#{indent}}/, "")
+
+        # @param body [String]
+        # @param items [Array<String>]
+        # @return [String]
+        def append_checks(body, items)
+          list = items.map { "#{list_item(it)}\n" }.join
+          body = "#{body}\n" unless body.end_with?("\n")
+          start = body =~ HOW_TO_VERIFY_LINE
+          return "#{body.rstrip}\n\n#{HOW_TO_VERIFY_HEADING}\n\n#{list}" unless start
+
+          heading_end = start + body[start..].index("\n").to_i + 1
+          rest = body[heading_end..].to_s
+          stop = rest =~ /^## / || rest.length
+          section = rest[0...stop].rstrip
+          joined = section.empty? ? "\n#{list}" : "#{section}\n#{list}"
+          tail = stop < rest.length ? "\n#{rest[stop..]}" : ""
+          "#{body[0...heading_end]}#{joined}#{tail}"
+        end
+
         # @return [Symbol, nil]
         def choice(meta, key, allowed, default, problems)
           return default unless meta.key?(key)
@@ -182,6 +398,26 @@ module OpenLanes
           items.map { |item| item.to_s.strip }.reject(&:empty?)
         end
 
+        # Each entry must be a string {Ordinal} can read; anything else is
+        # dropped and named, never coerced, since `034` has already become 28
+        # by the time it reaches here. `"034"` is normalised to `"034.00"`, so
+        # every caller compares one form.
+        #
+        # @return [Array<String>, nil] nil when the key is absent
+        def depends_on(meta, problems)
+          return nil unless meta.key?(DEPENDS_ON_KEY)
+
+          value = meta[DEPENDS_ON_KEY]
+          items = value.nil? ? [] : Array(value)
+          items.filter_map do |item|
+            ordinal = item.is_a?(String) && Ordinal.parse(item)
+            next ordinal.to_s if ordinal
+
+            problems << "#{DEPENDS_ON_KEY}: #{item.inspect} is not a quoted plan number like \"034.00\""
+            nil
+          end.uniq.sort
+        end
+
         # @return [Hash]
         def phases(value, problems)
           return {} if value.nil?