openlanes 3.0.0 → 3.1.0

data/lib/openlanes/live/outage_report.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module OpenLanes
+  module Live
+    # What the engine says once Redis is back: how long it was gone, how
+    # that was measured, and which copy of the run state won.
+    #
+    # The duration prefers this node's last heartbeat in Redis, because it
+    # is the last moment Redis provably had the engine's word. A heartbeat
+    # far older than the first failure is not that: it is what an RDB
+    # rollback restores, and measuring from it would overstate the outage by
+    # however long the snapshot was stale. Then the engine's own monotonic
+    # window is the answer, and `measured_by` says so.
+    class OutageReport
+      # Seconds a heartbeat may precede the first failure and still count.
+      # The publisher beats every tick, so a live one is a few seconds old.
+      FRESH = 15
+
+      # @param store [#hget]
+      # @param keys [OpenLanes::Live::Keys]
+      # @param node [OpenLanes::Live::Node]
+      # @param window [OpenLanes::Live::Outage::Window]
+      # @param reconciled_from [Symbol, nil] `:redis`, `:file` or nil, from
+      #   {RunRecord#reconcile}
+      def initialize(store:, keys:, node:, window:, reconciled_from:)
+        @store = store
+        @keys = keys
+        @node = node
+        @window = window
+        @reconciled_from = reconciled_from
+      end
+
+      # The `run.outage` wire shape (plan 022, shared with the page).
+      #
+      # @return [Hash]
+      def to_h
+        { started_at:      iso(started_at),
+          ended_at:        iso(@window.ended_at),
+          seconds:         seconds,
+          measured_by:     measured_by,
+          reconciled_from: @reconciled_from&.to_s }
+      end
+
+      # @return [String] one log line
+      def line
+        from = @reconciled_from ? "run state from #{@reconciled_from}" : "no run state to reconcile"
+        "Redis is back after #{seconds}s (by #{measured_by}), #{from}; resuming"
+      end
+
+      # @return [Integer]
+      def seconds
+        (heartbeat ? @window.ended_at - heartbeat : @window.seconds).round
+      end
+
+      # @return [String] `"heartbeat"` or `"clock"`
+      def measured_by = heartbeat ? "heartbeat" : "clock"
+
+      private
+
+      # @return [Time]
+      def started_at = heartbeat || @window.started_at
+
+      # This node's heartbeat, when it is from just before the first failure.
+      #
+      # @return [Time, nil]
+      def heartbeat
+        return @heartbeat if defined?(@heartbeat)
+
+        @heartbeat = read_heartbeat
+      end
+
+      # @return [Time, nil]
+      def read_heartbeat
+        json = @store.hget(@keys.nodes, @node.name) or return nil
+        at = Time.iso8601(JSON.parse(json)["heartbeat_at"].to_s)
+        at if at <= @window.started_at && @window.started_at - at <= FRESH
+      rescue JSON::ParserError, ArgumentError, Unavailable
+        nil
+      end
+
+      # @param time [Time]
+      # @return [String]
+      def iso(time) = time.utc.iso8601
+    end
+  end
+end

data/lib/openlanes/live/publisher.rb

@@ -60,6 +60,12 @@ module OpenLanes
         @on_lost = block
       end
 
+      # {OutageReport#to_h} of the outage this run last recovered from,
+      # published as `run.outage` from the next snapshot on.
+      #
+      # @return [Hash, nil]
+      attr_accessor :outage
+
       # @return [OpenLanes::Live::Meter]
       attr_reader :meter
 
@@ -77,11 +83,12 @@ module OpenLanes
         @meter.record(board.rows, now:)
         snapshot = build(board, now)
         json = JSON.generate(snapshot)
-        @store.multi do |tx|
+        EventBus.for(@store).transaction do |tx|
           tx.set(@keys.snapshot, json, ex: Keys::SNAPSHOT_TTL)
-          tx.xadd(@keys.board, { seq: snapshot[:seq], json: }, maxlen: Keys::BOARD_LENGTH)
+          tx.append(@keys.board, { seq: snapshot[:seq], json: }, maxlen: Keys::BOARD_LENGTH)
           tx.hset(@keys.nodes, @node.name, JSON.generate(@node.wire(heartbeat_at: now)))
         end
+        nudge(snapshot)
         lost = @claims&.renew || []
         unless lost.empty?
           UI.log("claims lost to another machine: #{lost.join(", ")}; stopping their agents")
@@ -153,9 +160,42 @@ module OpenLanes
           claims:      @claims,
           run_state:   @run_state,
           meter:       @meter,
+          # The URL the engine publishes through, not one read back from the
+          # environment: the page's status bar says which Redis the claims and
+          # run state really live in, and only the store that wrote them knows.
+          redis_url:   @store.url,
+          outage:      @outage,
           log:).to_h
       end
 
+      # Fields that move with the clock alone: the sequence number, the
+      # snapshot's time, this node's heartbeat, and how long each plan has
+      # been worked on. A car's `elapsed` is left in on purpose: while an
+      # agent runs, its seconds counter is what the page is there to show.
+      #
+      # @param snapshot [Hash]
+      # @return [Hash] what the page would see change
+      def content(snapshot)
+        snapshot.except(:seq, :at)
+                .merge(node:  snapshot[:node].except(:heartbeat_at),
+                  plans: Array(snapshot[:plans]).map { it.except(:elapsed) })
+      end
+
+      # Nudges the open pages ({News}) when this tick's snapshot says
+      # something the last one did not. The snapshot is still written every
+      # tick, because its expiry is how a node is known to be alive; only
+      # the nudge waits for news, so an engine with nothing to do is quiet.
+      #
+      # @param snapshot [Hash]
+      # @return [void]
+      def nudge(snapshot)
+        now = content(snapshot)
+        return if now == @published
+
+        News.publish(store: @store, keys: @keys, kind: "board")
+        @published = now
+      end
+
       # One more than the last published, even across an engine restart:
       # the API server reads a change of `seq` as news, and a restart that
       # counted from one again would look like the past.

data/lib/openlanes/live/run_record.rb

@@ -50,7 +50,7 @@ module OpenLanes
         @state_file = dispatcher.state_file
         redis = read_redis
         file = @state_file&.live
-        newer = [redis, file].compact.max_by { it["seq"].to_i }
+        newer = newest(redis, file)
         # A copy that is missing is behind, unless both are: then there is
         # nothing to keep until a person changes something.
         @in_redis = redis ? redis["seq"].to_i : (newer && -1) || 0
@@ -62,6 +62,37 @@ module OpenLanes
           ordinal, agent = key.split("/", 2)
           dispatcher.prefer_model(ordinal, agent, model)
         end
+        restore_concurrency(dispatcher)
+      end
+
+      # A `/concurrency` set before the restart holds after it (plan 020.00).
+      # One this run cannot take (a shared checkout runs one agent) is said
+      # once and dropped, rather than stopping the engine from starting.
+      #
+      # @param dispatcher [OpenLanes::Engine::Dispatcher]
+      # @return [void]
+      def restore_concurrency(dispatcher)
+        limit = @run_state.concurrency or return
+        dispatcher.concurrency = limit
+      rescue OpenLanes::Error => e
+        UI.log("concurrency #{limit} from before the restart not kept: #{e.message}")
+      end
+
+      # After Redis comes back: which copy is the newer, by the same `seq`
+      # rule as {#restore}. An RDB rollback leaves Redis behind or empty and
+      # the file wins. The engine's own state kept going through the outage,
+      # so nothing is restored from either; both marks are reset to what is
+      # really there, so the next {#flush} rewrites whichever copy is behind.
+      #
+      # @return [Symbol, nil] `:redis` or `:file`, or nil with neither copy
+      def reconcile
+        @warned = false
+        redis = read_redis
+        file = @state_file&.live
+        @in_redis = redis ? redis["seq"].to_i : -1
+        @in_file = file ? file["seq"].to_i : -1
+        newer = newest(redis, file) or return nil
+        newer.equal?(redis) ? :redis : :file
       end
 
       # Bring both copies up to the state's `seq`. The file is written by the
@@ -98,6 +129,13 @@ module OpenLanes
 
       private
 
+      # The copy with the higher `seq`; Redis on a tie, being listed first.
+      #
+      # @param redis [Hash, nil]
+      # @param file [Hash, nil]
+      # @return [Hash, nil]
+      def newest(redis, file) = [redis, file].compact.max_by { it["seq"].to_i }
+
       # @return [void]
       def mirror
         return unless @state_file && @in_file != @run_state.seq

data/lib/openlanes/live/run_state.rb

@@ -9,7 +9,8 @@ module OpenLanes
     # Held in the engine, and kept by {RunRecord} in Redis and in
     # `.plans/openlanes-state.json` (W6), so an engine that restarts still
     # knows them. Every change moves {#seq} on by one, which is how the
-    # record tells which of its two copies is newer. A model choice also
+    # record tells which of its two copies is newer. So does the concurrency
+    # a person set with `/concurrency` (plan 020.00). A model choice also
     # lives in the executor, which is what applies it; this copy is what the
     # page is shown and what a restart hands back to the executor.
     class RunState
@@ -18,9 +19,24 @@ module OpenLanes
         @held_questions = []
         @held_cars = []
         @models = {}
+        @concurrency = nil
         @seq = 0
       end
 
+      # @return [Integer, nil] the limit `/concurrency` set; nil when nobody did
+      def concurrency = @mutex.synchronize { @concurrency }
+
+      # @param limit [Integer]
+      # @return [void]
+      def concurrency=(limit)
+        @mutex.synchronize do
+          next if @concurrency == limit
+
+          @concurrency = limit
+          @seq += 1
+        end
+      end
+
       # @param id [String] `"<ordinal>/B<n>"`
       # @param held [Boolean]
       # @return [void]
@@ -67,7 +83,7 @@ module OpenLanes
       def to_h
         @mutex.synchronize do
           { "seq" => @seq, "held_questions" => @held_questions.dup, "held_cars" => @held_cars.dup,
-            "models" => @models.dup }
+            "models" => @models.dup }.merge(@concurrency ? { "concurrency" => @concurrency } : {})
         end
       end
 
@@ -80,6 +96,7 @@ module OpenLanes
           @held_questions = Array(data["held_questions"]).map(&:to_s)
           @held_cars = Array(data["held_cars"]).map(&:to_s)
           @models = (data["models"].is_a?(Hash) ? data["models"] : {}).to_h { |k, v| [k.to_s, v.to_s] }
+          @concurrency = data["concurrency"].is_a?(Integer) && data["concurrency"].positive? ? data["concurrency"] : nil
           @seq = data["seq"].to_i
         end
         self

data/lib/openlanes/live/session.rb

@@ -19,13 +19,16 @@ module OpenLanes
       # @param node [OpenLanes::Live::Node]
       # @param repo [String]
       # @param clock [Proc] wall time
+      # @param outage [OpenLanes::Live::Outage] what pauses the run while
+      #   Redis is gone; a spec hands in one on its own clock
       def initialize(store:, root:, tree:, agents:, project: nil, node: Node.current(root:), repo: Repo.for(root),
-        clock: -> { Time.now })
+        clock: -> { Time.now }, outage: Outage.new(store:, limit: Config.current.outage_limit, **Config.current.redis_backoff))
         @store = store
         @node = node
         @keys = Keys.new(repo:, node: node.name)
         @run_state = RunState.new
         @record = RunRecord.new(store:, keys: @keys, run_state: @run_state)
+        @outage = outage
         @claims = Claims.new(store:, keys: @keys)
         @publisher = Publisher.new(store:,
           keys: @keys,
@@ -69,20 +72,45 @@ module OpenLanes
       # @return [OpenLanes::Live::RunRecord]
       attr_reader :record
 
+      # @return [OpenLanes::Live::Outage]
+      attr_reader :outage
+
       # @return [Proc] the runner's `on_board:`
       def on_board = @publisher.to_proc
 
       # Wire the run in: the run state a previous engine left is taken back
-      # on the first tick, commands are applied at the top of each tick, and
-      # the log is heard from now on.
+      # on the first tick, commands are applied at the top of each tick, mail
+      # published to Redis is drained into the plans' `state.json`, and the
+      # log is heard from now on.
       #
       # @param dispatcher [OpenLanes::Engine::Dispatcher]
       # @return [void]
       def attach(dispatcher)
         @publisher.listen
         @publisher.on_lost { |ordinals| dispatcher.fence(ordinals) }
+        # First, so a tick that finds Redis gone pauses before anything else
+        # on it asks Redis for something (W32).
+        dispatcher.before_tick(&@outage)
         dispatcher.before_tick(&@record)
         dispatcher.before_tick(&@commands)
+        dispatcher.mail = Mail.new(store: @store, keys: @keys)
+        @outage.on_resume { recover(it) }
+      end
+
+      # Redis answers again: say how long it was gone and which copy of the
+      # run state won, and publish that as `run.outage`.
+      #
+      # @param window [OpenLanes::Live::Outage::Window]
+      # @return [OpenLanes::Live::OutageReport]
+      def recover(window)
+        report = OutageReport.new(store: @store,
+          keys: @keys,
+          node: @node,
+          window:,
+          reconciled_from: @record.reconcile)
+        UI.log(report.line)
+        @publisher.outage = report.to_h
+        report
       end
 
       # The run is over: the run state is written down, claims go back, and
@@ -101,7 +129,13 @@ module OpenLanes
       end
 
       # @return [String] where, with the password masked, and as whom
-      def describe = "#{Live.mask(@store.url)} as #{@node.label} (#{@node.name})"
+      def describe = described.join(" ")
+
+      # The same, in the two parts a narrow box may break it between: the
+      # node id is long, and wraps mid-word when left to the box.
+      #
+      # @return [Array(String, String)] `"redis://… as kig@host"` and `"(<node id>)"`
+      def described = ["#{Live.mask(@store.url)} as #{@node.label}", "(#{@node.name})"]
     end
   end
 end

data/lib/openlanes/live/snapshot.rb

@@ -13,17 +13,6 @@ module OpenLanes
     # to the page's fixture, level by level, so a field renamed on one side
     # fails the other's suite.
     class Snapshot
-      # How an agent marks a question as answerable with Yes or No (W30), on
-      # its own line under the question's heading. The agents' prompt shows
-      # it, and {#questions} looks for it; neither spells it twice.
-      YES_NO_MARK = "answers: yes, no"
-
-      # {YES_NO_MARK}, read forgivingly: brackets, case and spacing vary.
-      YES_NO = /answers:\s*\[?\s*yes\s*,\s*no\s*\]?/i
-
-      # Any Markdown heading, which ends the body of the question above it.
-      HEADING = /^[ \t]{0,3}\#{1,6}[ \t]/
-
       # Plan states finished with, kept off "Choose an existing plan".
       FINISHED = %i[approved deployed discarded].freeze
 
@@ -42,9 +31,16 @@ module OpenLanes
       # @param meter [OpenLanes::Live::Meter]
       # @param log [Array<Hash>] `LogLine`s, newest last
       # @param adapter [OpenLanes::Adapters::Base] whose models the page offers
+      # @param judge [#call, nil] a second opinion on whether a question asks
+      #   to choose ({ChoiceJudge}); nil leaves the parser's verdict alone
+      # @param redis_url [String, nil] the store the engine itself is using,
+      #   unredacted: the snapshot redacts it ({Live.redact})
+      # @param outage [Hash, nil] {OutageReport#to_h} of the outage this run
+      #   last recovered from; nil when there was none
       def initialize(board:, tree:, agents:, node:, repo:, project:, seq:, description: nil, at: Time.now,
         started_at: nil, claims: nil, run_state: RunState.new, meter: Meter.new, log: [],
-        adapter: Adapters.for(Adapters::DEFAULT))
+        adapter: Adapters.for(Adapters::DEFAULT), judge: Live.choice_judge, redis_url: nil,
+        outage: nil)
         @board = board
         @tree = tree
         @agents = agents
@@ -60,6 +56,9 @@ module OpenLanes
         @meter = meter
         @log = log
         @adapter = adapter
+        @judge = judge
+        @redis_url = redis_url
+        @outage = outage
       end
 
       # @return [Hash]
@@ -76,8 +75,10 @@ module OpenLanes
           stations:    Stations.all(@agents).map(&:wire),
           plans:       mine,
           backlog:     backlog(subjects, mine.map { it[:ordinal] }),
+          bombs:       bombs(subjects),
           models:      @adapter.models.map(&:wire),
           autocompact: Adapters::AUTOCOMPACT / 100.0,
+          redis_url:   @redis_url && Live.redact(@redis_url),
           log:         @log }
       end
 
@@ -93,7 +94,9 @@ module OpenLanes
           up:             @board.up.to_i,
           down:           @board.down.to_i,
           cost:           plans.sum { it[:cost] }.round(4),
-          agents_working: @board.running.to_i }
+          agents_working: @board.running.to_i,
+          jobs:           @board.jobs.to_i,
+          outage:         @outage }
       end
 
       # @return [String]
@@ -121,12 +124,15 @@ module OpenLanes
         ordinal = subject.feature.ordinal.to_s
         state = Plans::PlanState.for(subject.feature.path)
         stages = state.stages
+        finished = state.finished
         rows = @board.rows.select { it.ordinal == ordinal }
         spent = @meter.for(ordinal, method(:price))
         started = @meter.started_at(ordinal)
+        mailbox = Plans.mailbox(subject.feature.path)
         { ordinal:,
           title:       subject.feature.title,
           slug:        subject.feature.slug,
+          summary:     Plans::Spec.summary(subject.read(Plans::Spec::FILENAME).to_s),
           status:      status(subject.status),
           lane:        Plans::Spec.for(subject).lane.to_s,
           station:     Stations.key_for(subject.status.key, before: stages.last&.fetch("from", nil)&.to_sym).to_s,
@@ -136,15 +142,20 @@ module OpenLanes
           started_at:  started && iso(started),
           elapsed:     started ? (@at - started).round : 0,
           cars:        rows.map { car(it, subject, stages) },
-          pr:          pull_request(subject),
+          pr:          pull_request(subject, finished),
           questions:   questions(subject, state),
           interrupted: interrupted(stages, rows),
-          claimed_by:  claimed_by(ordinal) }
+          claimed_by:  claimed_by(ordinal),
+          unacked:     mailbox.unacked,
+          mail:        mailbox.unacked_pairs,
+          last_known:  last_known(state),
+          locked:      Plans::Lock.read(subject.feature.path)&.to_json_hash,
+          finished:    finished && { kind: finished.kind, at: iso(finished.at) } }
       end
 
       # @param status [OpenLanes::Plans::Status]
       # @return [Hash] `Status`
-      def status(status) = { key: status.key.to_s, emoji: status.emoji, label: status.label }
+      def status(status) = { key: status.key.to_s, emoji: status.emoji, label: status.label, note: status.note.to_s.delete("`") }
 
       # @param subjects [Array<OpenLanes::Plans::Subject>]
       # @param taken [Array<String>] ordinals already on the board
@@ -158,6 +169,24 @@ module OpenLanes
         end
       end
 
+      # Every 💣 in the tree that is not another machine's, on the board or
+      # not: a bomb halts the whole run, so the page shows it whatever this
+      # node is working on (plan 009).
+      #
+      # @param subjects [Array<OpenLanes::Plans::Subject>]
+      # @return [Array<Hash>] `Bomb`
+      def bombs(subjects)
+        aging = Lifecycle::Aging.new(tree: @tree, now: @at)
+        subjects.select { it.status.key == :bomb && !foreign?(it.feature.ordinal.to_s) }.map do |s|
+          resume = Plans::PlanState.for(s.feature.path).resume_until
+          { plan:          s.feature.ordinal.to_s,
+            slug:          s.feature.slug,
+            blocked_md:    s.read("blocked.md").to_s,
+            blocked_since: iso(aging.started_at(s)),
+            resume_until:  resume && iso(resume) }
+        end
+      end
+
       # ---- cars -------------------------------------------------------------
 
       # @param row [OpenLanes::Engine::Board::Row]
@@ -183,6 +212,7 @@ module OpenLanes
           elapsed:       row.elapsed.to_i,
           remaining:     row.remaining,
           held:          @run_state.car_held?(row.key),
+          subagents:     Array(row.running),
           next_model:    next_model(row) }
       end
 
@@ -229,16 +259,24 @@ module OpenLanes
       # ---- pull request, interruption, claim --------------------------------
 
       # @param subject [OpenLanes::Plans::Subject]
+      # @param finished [OpenLanes::Plans::PlanState::Finished, nil]
       # @return [Hash, nil] `PullRequest`
-      def pull_request(subject)
+      def pull_request(subject, finished)
         pr = subject.pull_requests.find(&:open?) || subject.pull_requests.last or return nil
-        { number: pr.number.to_s[/\d+/].to_i, url: pr.url, state: pr_state(pr, subject), ci: nil, merged_at: nil }
+        merged_at = finished.at if pr.merged? && finished&.merged?
+        { number: pr.number.to_s[/\d+/].to_i, url: pr.url, state: pr_state(pr, subject, finished), ci: nil,
+          merged_at: merged_at && iso(merged_at) }
       end
 
+      # hansolo's approval leaves the plan at 👀 with its pull request open,
+      # which the status key alone reads as "open": `finished` is what says
+      # it was approved, so the page's pill turns green.
+      #
       # @return [String]
-      def pr_state(pr, subject)
+      def pr_state(pr, subject, finished)
         return "merged" if pr.merged?
         return "closed" unless pr.open?
+        return "approved" if finished&.kind == "approved"
 
         { rejected: "rejected", approved: "approved" }.fetch(subject.status.key, "open")
       end
@@ -255,6 +293,18 @@ module OpenLanes
         { agent: last["agent"], at: last["finished_at"] || last["started_at"], note: last["note"].to_s }
       end
 
+      # Where each interrupted agent stood, as the next round will read it.
+      # Read-only: an unacked count or a resume record never changes a round.
+      #
+      # @param state [OpenLanes::Plans::PlanState]
+      # @return [Array<Hash>] `LastKnown`, one per agent
+      def last_known(state)
+        state.last_known_states.map do |agent, entry|
+          { agent:, source: entry.source, at: entry.at, round: entry.round, status: entry.status,
+            next_step: entry.next_step, note: entry.note }
+        end
+      end
+
       # @param ordinal [String]
       # @return [String, nil] the node id, without its checkout
       def claimed_by(ordinal) = @claims&.held_by(ordinal)&.then { it.split(":").first }
@@ -265,17 +315,25 @@ module OpenLanes
 
       # ---- questions --------------------------------------------------------
 
-      # The questions `blocked.md` still asks, each with its body, whether it
-      # is a yes/no question, and who asked.
+      # The questions `blocked.md` still asks, each with its context, the
+      # options it offers (D3), and who asked; then the harness's own
+      # requests for more time or rounds (E1), and R4's quality question on
+      # the plan that asked it.
       #
       # @param subject [OpenLanes::Plans::Subject]
       # @param state [OpenLanes::Plans::PlanState]
       # @return [Array<Hash>] `Question`
       def questions(subject, state)
+        blocked(subject, state) + Engine::Extensions.questions(subject, state) +
+          Engine::QualityQuestion.questions(subject, state)
+      end
+
+      # @return [Array<Hash>] `Question`, from `blocked.md`
+      def blocked(subject, state)
         open = Lifecycle::Unblocker.questions(subject).reject(&:answered)
         return [] if open.empty?
 
-        bodies = bodies(subject.read("blocked.md").to_s)
+        bodies = Plans::BlockedFile.bodies(subject.read("blocked.md").to_s)
         asker = state.signatures.rfind { it["status"] == "Blocked" }
         asked_at = asker&.fetch("at", nil) || iso(File.mtime(File.join(subject.feature.path, "blocked.md")))
         open.map { |q| question(subject, q, bodies.fetch(q.number, ""), asker, asked_at) }
@@ -284,34 +342,37 @@ module OpenLanes
       # @return [Hash]
       def question(subject, open, body, asker, asked_at)
         id = "#{subject.feature.ordinal}/B#{open.number}"
-        yes_no = open.heading.match?(YES_NO) || body.match?(YES_NO)
+        choices = choices(open.heading, body)
         { id:,
           number:   open.number,
-          heading:  open.heading.sub(YES_NO, "").strip,
-          body:     body.lines.grep_v(/\A\s*#{YES_NO.source}\s*\z/i).join.strip,
+          kind:     "block",
+          heading:  open.heading.sub(Plans::Choices::YES_NO, "").strip,
+          body:     choices ? choices.context : body.strip,
           agent:    asker&.fetch("agent", nil),
           owner:    subject.status.key == :product_blocked ? "product" : "technical",
-          answers:  yes_no ? %w[yes no] : nil,
+          options:  choices&.to_a,
           held:     @run_state.question_held?(id),
           asked_at: }
       end
 
-      # @param text [String] the whole of blocked.md
-      # @return [Hash{Integer => String}] each open question's number to the
-      #   lines under its heading, up to the next heading
-      def bodies(text)
-        found = {}
-        current = nil
-        text.each_line do |line|
-          if (number = line[Plans::OPEN_BLOCK, 1])
-            current = found[number.to_i] = +""
-          elsif line.match?(HEADING) || line.match?(Plans::ANSWER_BLOCK)
-            current = nil
-          elsif current
-            current << line
-          end
-        end
-        found
+      # The options a question offers, or nil for one that wants words.
+      #
+      # A question its agent marked yes/no (W30) is taken at its word. Any
+      # other the parser found options in goes past the judge, which may say
+      # the list was not a choice after all; it is never asked about a
+      # question the parser found nothing in, since there would be no buttons
+      # to show.
+      #
+      # @param heading [String]
+      # @param body [String]
+      # @return [OpenLanes::Plans::Choices, nil]
+      def choices(heading, body)
+        return Plans::Choices.yes_no(body) if heading.match?(Plans::Choices::YES_NO)
+
+        found = Plans::Choices.parse(body) or return nil
+        return found if body.match?(Plans::Choices::YES_NO)
+
+        @judge&.call(body) == false ? nil : found
       end
 
       # @param time [Time]

data/lib/openlanes/live/stations.rb

@@ -25,17 +25,20 @@ module OpenLanes
         def wire = { key: key.to_s, label:, agents: }
       end
 
-      # Key, label and the states folded into it, in spine order. ⭐️ Planned
+      # Key, label and the states folded into it, in spine order. ⭐ Planned
       # sits with 🟡 Building and 🟢 Ready for Review with 👀 In Review,
       # because on the board each pair is one stop with the same agents.
+      # 🔴 Rejected sits at Building too: luke and rey rework it there, and
+      # placed by the spine alone it showed them at Building UI, a stop whose
+      # agent list leaves luke out.
       GROUPS = [
         [:new, "New", %i[new]],
         [:researched, "Researched", %i[researched retroactive]],
         [:ready_for_planning, "Planning", %i[ready_for_planning]],
-        [:building, "Building", %i[planned building]],
+        [:building, "Building", %i[planned building rejected]],
         [:building_ui, "Building UI", %i[building_ui]],
-        [:in_review, "Review", %i[ready_for_review in_review]],
-        [:pr, "Pull request", %i[approved deployed]]
+        [:in_review, "Review", %i[ready_for_review in_review verifying]],
+        [:pr, "Pull request", %i[completed approved deployed]]
       ].freeze
 
       module_function
@@ -48,10 +51,11 @@ module OpenLanes
         end
       end
 
-      # The stop a plan in +state+ is shown at. A state off the spine (🔴,
-      # 💩, 😱) is shown where the spine takes it next; one with no way
-      # forward (⭕️, 🅱️) where the plan was when it stopped, which only
-      # its history knows.
+      # The stop a plan in +state+ is shown at. A state a {GROUPS} entry
+      # names is shown at that stop, which is how 🔴 Rejected lands at
+      # Building. Any other state off the spine (💩, 😱) is shown where the
+      # spine takes it next; one with no way forward (⭕, 🛑) where the
+      # plan was when it stopped, which only its history knows.
       #
       # @param state [Symbol]
       # @param before [Symbol, nil] the state the plan was worked in last