openlanes 3.0.1 → 3.1.0

data/evals/cases/luthen-rael-planner/plan-fast/fail/plan/plan.md

@@ -0,0 +1,12 @@
+# Plan
+
+Six units, U6 is the integration check.
+
+## Order
+
+U1, then U2 to U5 in parallel, then U6.
+
+> [!NOTE]
+>
+> [2026-09-04 01:10:00 PM PDT] [ agent: luthen-rael-planner   status: Started, round 1 ]
+> [2026-09-04 01:14:30 PM PDT] [ agent: luthen-rael-planner   status: Completed, round 1 ]

data/evals/cases/{palpatine-planner → luthen-rael-planner}/plan-fast/pass/plan/plan.md

@@ -8,5 +8,5 @@ One unit; it is also the integration check, since there is no front end.
 
 > [!NOTE]
 >
-> [2026-09-04 01:10:00 PM PDT] [ agent: palpatine-planner   status: Started, round 1 ]
-> [2026-09-04 01:14:30 PM PDT] [ agent: palpatine-planner   status: Completed, round 1 ]
+> [2026-09-04 01:10:00 PM PDT] [ agent: luthen-rael-planner   status: Started, round 1 ]
+> [2026-09-04 01:14:30 PM PDT] [ agent: luthen-rael-planner   status: Completed, round 1 ]

data/evals/cases/{palpatine-planner → luthen-rael-planner}/plan-fast.yml

@@ -1,5 +1,5 @@
 id: plan-fast
-agent: palpatine-planner
+agent: luthen-rael-planner
 depth: fast
 description: >
   A one-change spec. At fast depth the plan is one or two units with every

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/plan/plan.md

@@ -0,0 +1,20 @@
+# Plan
+
+1. U1 Remove the last reader of `legacy_email`, then drop the column.
+
+## Merge risk, PR #21
+
+**Verdict:** auto
+
+**Triggers:** none.
+
+**Signals:** none.
+
+**Unplanned files:** none.
+
+**Rollback:** `git revert` the merge.
+
+> [!NOTE]
+>
+> [2026-10-20 10:00:00 AM PDT] [ agent: palpatine-risk-assessor   status: Started, round 1 ]
+> [2026-10-20 10:01:00 AM PDT] [ agent: palpatine-risk-assessor   status: Completed, round 1 (auto) ]

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/plan/pull-requests.md

@@ -0,0 +1,5 @@
+# Pull Requests
+
+| Pull Request Number | Pull Request Name | Status |
+| ------------------: | :---------------- | -----: |
+| 21 | [[001.00] Drop Legacy Email](https://github.com/example/accounts/pull/21) | Open 🟡 |

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/plan/spec.md

@@ -0,0 +1,5 @@
+# Drop Legacy Email
+
+## Goal
+
+`users.legacy_email` is gone; nothing reads it any more.

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/repo/db/migrate/20261020120000_drop_legacy_email.rb

@@ -0,0 +1,5 @@
+class DropLegacyEmail < ActiveRecord::Migration[8.0]
+  def change
+    remove_column :users, :legacy_email, :string
+  end
+end

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/run.json

@@ -0,0 +1 @@
+{"seconds":60,"tokens":15000,"state":"completed"}

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/plan/plan.md

@@ -0,0 +1,25 @@
+# Plan
+
+1. U1 Remove the last reader of `legacy_email`, then drop the column.
+
+## Merge risk, PR #21
+
+**Verdict:** manual
+
+**Triggers:** schema and data: `db/migrate/20261020120000_drop_legacy_email.rb:3` drops `users.legacy_email`; the old code still running during the deploy overlap may read it.
+
+**Signals:** none.
+
+**Unplanned files:** none.
+
+**Rollback:** a revert does not restore the dropped data; it needs a restore of the column from the last backup. Without a backup the drop is permanent.
+
+**For the human:**
+
+- Confirm a backup of `users.legacy_email` exists before merging.
+- Confirm no deployed code reads the column.
+
+> [!NOTE]
+>
+> [2026-10-20 10:00:00 AM PDT] [ agent: palpatine-risk-assessor   status: Started, round 1 ]
+> [2026-10-20 10:03:00 AM PDT] [ agent: palpatine-risk-assessor   status: Completed, round 1 (manual) ]

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/plan/pull-requests.md

@@ -0,0 +1,5 @@
+# Pull Requests
+
+| Pull Request Number | Pull Request Name | Status |
+| ------------------: | :---------------- | -----: |
+| 21 | [[001.00] Drop Legacy Email](https://github.com/example/accounts/pull/21) | Open 🟡 |

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/plan/spec.md

@@ -0,0 +1,5 @@
+# Drop Legacy Email
+
+## Goal
+
+`users.legacy_email` is gone; nothing reads it any more.

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/repo/db/migrate/20261020120000_drop_legacy_email.rb

@@ -0,0 +1,5 @@
+class DropLegacyEmail < ActiveRecord::Migration[8.0]
+  def change
+    remove_column :users, :legacy_email, :string
+  end
+end

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/run.json

@@ -0,0 +1 @@
+{"seconds":180,"tokens":40000,"state":"completed"}

data/evals/cases/palpatine-risk-assessor/risk-medium.yml

@@ -0,0 +1,47 @@
+id: risk-medium
+agent: palpatine-risk-assessor
+depth: medium
+description: >
+  One ready-to-merge pull request whose branch adds a migration that drops
+  `users.legacy_email`, a hard trigger (schema and data). palpatine must
+  append a "Merge risk, PR #21" section naming the migration, write a
+  rollback, and sign manual. Signing auto means the trigger was missed.
+  palpatine judges; it changes no code.
+fixture:
+  state: completed
+  slug: drop-legacy-email
+  files:
+    spec.md: |
+      # Drop Legacy Email
+
+      ## Goal
+
+      `users.legacy_email` is gone; nothing reads it any more.
+    plan.md: |
+      # Plan
+
+      1. U1 Remove the last reader of `legacy_email`, then drop the column.
+    pull-requests.md: |
+      # Pull Requests
+
+      | Pull Request Number | Pull Request Name | Status |
+      | ------------------: | :---------------- | -----: |
+      | 21 | [[001.00] Drop Legacy Email](https://github.com/example/accounts/pull/21) | Open 🟡 |
+  repo:
+    db/migrate/20261020120000_drop_legacy_email.rb: |
+      class DropLegacyEmail < ActiveRecord::Migration[8.0]
+        def change
+          remove_column :users, :legacy_email, :string
+        end
+      end
+expect:
+  signed: manual
+  sections:
+    plan.md: ["Merge risk, PR #21"]
+  contains:
+    plan.md: ["/\\*\\*Verdict:\\*\\*\\s*manual/", "drop_legacy_email", "/\\*\\*Rollback:\\*\\*/"]
+  untouched: ["**/*"]
+  depth:
+    medium:
+      max_seconds: 600
+      max_tokens: 150000

data/evals/cases/yoda-writer/spec-medium/pass/plan/spec.md

@@ -60,4 +60,4 @@ When this ships, a cart cannot hold a quantity checkout would refuse, the limit
 >
 > [2026-09-04 12:02:11 PM PDT] [ agent: yoda-writer   status: Started, round 1 ]
 > [2026-09-04 12:09:40 PM PDT] [ agent: yoda-writer   status: Completed, round 1 ]
-> [2026-09-04 12:09:41 PM PDT] [ next: palpatine-planner ]
+> [2026-09-04 12:09:41 PM PDT] [ next: luthen-rael-planner ]

data/lib/openlanes/adapters/base.rb

@@ -47,30 +47,44 @@ module OpenLanes
       # @return [OpenLanes::Adapters::Model, nil]
       def model_entry(name) = models.find { |m| m.id == name.to_s }
 
+      # What this CLI can do. Abstract on purpose: every adapter declares all
+      # of it, and the Executor and Dispatcher branch on these, never on
+      # {#name}.
+      #
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = raise NotImplementedError, "#{self.class} must declare its capabilities"
+
+      # The flags that start this CLI without the operator's personal
+      # plugins, skills, hooks and MCP servers; empty where {#argv} builds
+      # them itself.
+      #
+      # @return [Array<String>]
+      def lean_flags = []
+
       # What, sent into a resumed session, makes this CLI compact it (W28);
       # nil for a CLI that cannot resume one, whose agents are therefore never
       # compacted mid-round.
       #
       # @return [String, nil]
-      def compact_prompt = nil
+      def compact_prompt = capabilities.compact_prompt
 
       # @return [Boolean] whether an agent on this CLI can be compacted and
       #   carried on in the same session
-      def compacts? = !compact_prompt.nil?
+      def compacts? = capabilities.compacts
 
       # Whether {#argv} honours {Invocation#resume}. The copilot (W17) keeps
       # one conversation across messages only on a CLI that says yes; on any
       # other each message starts afresh, and says so.
       #
       # @return [Boolean]
-      def resumes? = false
+      def resumes? = capabilities.resumes
 
       # Whether the CLI itself refuses the denied tools, rather than only being
       # asked not to use them. The prompt says which, because telling an agent
       # a guard exists when it does not is how it stops being careful.
       #
       # @return [Boolean]
-      def enforces_tool_denial? = false
+      def enforces_tool_denial? = capabilities.enforces_tool_denial
     end
   end
 end

data/lib/openlanes/adapters/capabilities.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Adapters
+    # What one CLI can do, declared in one place. Every adapter states every
+    # field: a capability inherited as a silent default is how codex was once
+    # assumed to refuse denied tools it never refused.
+    #
+    # @!attribute [r] compacts
+    #   @return [Boolean] an agent on this CLI can be compacted and carried on
+    #     in the same session
+    # @!attribute [r] resumes
+    #   @return [Boolean] {Base#argv} honours {Invocation#resume}
+    # @!attribute [r] enforces_tool_denial
+    #   @return [Boolean] the CLI itself refuses the denied tools
+    # @!attribute [r] compact_prompt
+    #   @return [String, nil] what, sent into a resumed session, compacts it;
+    #     nil exactly when {#compacts} is false
+    Capabilities = Data.define(:compacts, :resumes, :enforces_tool_denial, :compact_prompt) do
+      def initialize(compacts:, resumes:, enforces_tool_denial:, compact_prompt:)
+        if compacts == compact_prompt.nil?
+          raise ArgumentError, "compact_prompt must be given exactly when compacts is true"
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/openlanes/adapters/claude.rb

@@ -105,18 +105,21 @@ module OpenLanes
         rank && rank > LADDER.index(CEILING) ? CEILING : model.to_s
       end
 
-      # @return [Boolean]
-      def enforces_tool_denial? = true
+      # `--disallowedTools` is refused by the CLI itself, and `--resume
+      # <session id>` carries a conversation on. `claude -p --resume <id>
+      # "/compact"` compacts the session and prints a `compact_boundary`
+      # event; the agent cannot run it on itself, because `/compact` is the
+      # caller's command, not a tool.
+      CAPABILITIES = Capabilities.new(compacts: true,
+        resumes: true,
+        enforces_tool_denial: true,
+        compact_prompt: "/compact")
+
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = CAPABILITIES
 
-      # @return [Boolean] `--resume <session id>` carries a conversation on
-      def resumes? = true
-
-      # `claude -p --resume <id> "/compact"` compacts the session and prints a
-      # `compact_boundary` event; the agent cannot run it on itself, because
-      # `/compact` is the caller's command, not a tool.
-      #
-      # @return [String]
-      def compact_prompt = "/compact"
+      # @return [Array<String>]
+      def lean_flags = LEAN
 
       # @return [Hash{String => String}]
       def environment = { AUTOCOMPACT_VARIABLE => AUTOCOMPACT.to_s }

data/lib/openlanes/adapters/codex.rb

@@ -13,6 +13,15 @@ module OpenLanes
       # Codex says `xhigh` for the top of its scale and has no `max`.
       EFFORT = { "low" => "low", "medium" => "medium", "high" => "high", "xhigh" => "xhigh", "max" => "xhigh" }.freeze
 
+      # No session to resume, so nothing to compact, and no denylist of its own.
+      CAPABILITIES = Capabilities.new(compacts: false,
+        resumes: false,
+        enforces_tool_denial: false,
+        compact_prompt: nil)
+
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = CAPABILITIES
+
       # @param invocation [OpenLanes::Adapters::Invocation]
       # @return [Array<String>]
       def argv(invocation)

data/lib/openlanes/adapters/pi.rb

@@ -8,6 +8,16 @@ module OpenLanes
       # Pi's `--thinking` scale already uses these words.
       THINKING = Adapters::EFFORTS
 
+      # `--no-session` every time: nothing resumes, nothing compacts, and
+      # nothing refuses a denied tool but the after-check.
+      CAPABILITIES = Capabilities.new(compacts: false,
+        resumes: false,
+        enforces_tool_denial: false,
+        compact_prompt: nil)
+
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = CAPABILITIES
+
       # @param invocation [OpenLanes::Adapters::Invocation]
       # @return [Array<String>]
       def argv(invocation)

data/lib/openlanes/adapters/stream.rb

@@ -15,6 +15,15 @@ module OpenLanes
     # its events keeps working, and one that stops reporting usage shows a
     # meter at zero rather than a crash.
     class Stream
+      # Events that carry part of a message still being written. Only its
+      # finished lines are read out of one, and the closing message does not
+      # read them again (see {#take_partial}).
+      PARTIAL = /delta|update|partial|chunk/i
+
+      # Events that repeat messages already closed: pi's `turn_end` and
+      # `agent_end`, or anything carrying a `messages` list.
+      SUMMARY = /turn|agent|session|run/i
+
       # @param trace [String, nil] where every line is kept verbatim
       # @yieldparam progress [OpenLanes::Execution::Transcript::Progress]
       def initialize(trace: nil, &on_progress)
@@ -30,6 +39,11 @@ module OpenLanes
         @activity = nil
         @result = nil
         @error = nil
+        @journal = []
+        @heard = {}
+        @closed = Hash.new(0)
+        @open = { text: +"", taken: 0 }
+        @pending = Hash.new(0)
       end
 
       # @return [Integer] tokens sent, cached input included
@@ -59,6 +73,10 @@ module OpenLanes
       # @return [String, nil]
       attr_reader :trace_path
 
+      # @return [Array<OpenLanes::Plans::Journal::Entry, OpenLanes::Plans::Journal::Rejection>]
+      #   the journal lines printed so far
+      def journal = @journal.dup
+
       # @return [Integer, nil]
       attr_accessor :pid
 
@@ -79,8 +97,19 @@ module OpenLanes
       # @return [Boolean]
       def failed? = !@error.nil?
 
+      # No sub-agents, running or spawned: codex and pi never say they delegated.
+      #
       # @return [OpenLanes::Execution::Transcript::Progress]
-      def progress = Execution::Transcript::Progress.new(activity:, up:, down:, subagents: 0, pid:, message: nil)
+      def progress
+        Execution::Transcript::Progress.new(activity:,
+          up:,
+          down:,
+          subagents: 0,
+          pid:,
+          message: nil,
+          running: [],
+          journal: @journal.dup.freeze)
+      end
 
       # @param chunk [String, nil]
       # @return [void]
@@ -137,9 +166,124 @@ module OpenLanes
           @activity = said.lines.first.to_s.strip[0, Execution::Transcript::LIMIT]
           @result = said
         end
+        unless type.match?(/tool|command|exec/i)
+          if type.match?(PARTIAL)
+            take_partial(event)
+          else
+            take_journal(event, summary: type.match?(SUMMARY) || event.key?("messages"))
+          end
+        end
         @on_progress&.call(progress)
       end
 
+      # Journal lines (M2) in what the agent itself said, in every text block
+      # of every message it finished. Not {#text_in}, which takes the first
+      # `text` anywhere in the event: that can be a tool's output, which would
+      # make a file the agent read into its memory, and it misses a line in a
+      # message's second block.
+      #
+      # A CLI read by shape delivers the same message more than once: as it
+      # closes, and again in a summary of the turn or the run. A message with
+      # an id is taken once by its id. One without is always taken as it
+      # closes, since an agent may mean `todo U1` again after it said `done
+      # U1`; a summary skips as many copies of its words as have closed, and
+      # takes the rest.
+      #
+      # @param event [Hash]
+      # @param summary [Boolean] whether the event repeats closed messages
+      # @return [void]
+      def take_journal(event, summary:)
+        seen = Hash.new(0)
+        messages_in(event).each do |message|
+          texts = texts_of(message)
+          next if texts.empty?
+
+          if (id = message["id"])
+            next if @heard.key?(id)
+
+            @heard[id] = true
+          else
+            next if summary && (seen[texts] += 1) <= @closed[texts]
+
+            @closed[texts] += 1
+          end
+          texts.flat_map { Plans::Journal.scan(it) }.each { keep(it) }
+          @open = { text: +"", taken: 0 }
+        end
+      end
+
+      # The finished lines of a message still being written, as they arrive,
+      # so an agent killed before the message closes keeps what it printed.
+      # An event carries either the message so far (pi's `message`, codex's
+      # `item`) or only the newest piece of it (a `delta`).
+      #
+      # @param event [Hash]
+      # @return [void]
+      def take_partial(event)
+        whole = messages_in(event).map { texts_of(it).join("\n") }.reject(&:empty?).last
+        whole ? @open[:text] = +whole : @open[:text] << delta_in(event).to_s
+        cut = @open[:text].rindex("\n") or return
+
+        entries = Plans::Journal.scan(@open[:text][0..cut])
+        entries.drop(@open[:taken]).each do |entry|
+          @journal << entry
+          @pending[entry] += 1
+        end
+        @open[:taken] = entries.size
+      end
+
+      # An entry from a closing message, unless it was already taken from that
+      # message while it was being written.
+      #
+      # @param entry [OpenLanes::Plans::Journal::Entry, OpenLanes::Plans::Journal::Rejection]
+      # @return [void]
+      def keep(entry)
+        return @pending[entry] -= 1 if @pending[entry].positive?
+
+        @journal << entry
+      end
+
+      # @param event [Hash]
+      # @return [String, nil] the newest piece of text a partial event carries
+      def delta_in(event)
+        [event["delta"], event.dig("assistantMessageEvent", "delta")].each do |delta|
+          return delta if delta.is_a?(String)
+          return delta["text"] if delta.is_a?(Hash) && delta["text"].is_a?(String)
+        end
+        nil
+      end
+
+      # The agent's own messages an event carries: one under `item` (codex)
+      # or `message` (pi), a list under `messages`, or the event itself when
+      # it is a message with its words at the top level. A message that names
+      # a role other than the assistant's is a prompt or a tool result, and
+      # an item typed as anything but a message is a command, a file change
+      # or reasoning.
+      #
+      # @param event [Hash]
+      # @return [Array<Hash>]
+      def messages_in(event)
+        itself = event.key?("content") || event["text"].is_a?(String) ? event : nil
+        found = [event["item"], event["message"], *Array(event["messages"]), itself]
+        found.select do |message|
+          message.is_a?(Hash) &&
+            [nil, "assistant"].include?(message["role"]) &&
+            (message["type"].nil? || message["type"].to_s.match?(/message|assistant/i))
+        end
+      end
+
+      # @param message [Hash]
+      # @return [Array<String>] its text, block by block, tool calls left out
+      def texts_of(message)
+        content = message["content"]
+        blocks = if content.is_a?(Array)
+                   content.select { it.is_a?(Hash) && [nil, "text", "output_text"].include?(it["type"]) }.map { it["text"] }
+                 else
+                   [message["text"], content]
+                 end
+        blocks.select { it.is_a?(String) && !it.strip.empty? }
+      end
+
       # Usage counts arrive per turn, so they are added rather than replaced.
       #
       # @param event [Hash]

data/lib/openlanes/adapters.rb

@@ -98,6 +98,13 @@ module OpenLanes
       klass.new
     end
 
+    # The lean-start flags of one CLI, so a caller building its own argv
+    # never names an adapter class.
+    #
+    # @param name [String, Symbol, nil]
+    # @return [Array<String>]
+    def lean_flags(name = DEFAULT) = self.for(name).lean_flags
+
     # @param name [String, Symbol, nil]
     # @return [Boolean]
     def known?(name) = registry.key?((name || DEFAULT).to_s)

data/lib/openlanes/agents/agent.rb

@@ -89,11 +89,12 @@ module OpenLanes
       # @return [Boolean]
       def serves?(lane) = lanes.empty? || lanes.include?(lane.to_sym)
 
-      # The word after the hyphen: `researcher`, `backend`. What the screen's
-      # agent column shows, the name being too long for it.
+      # The word after the last hyphen: `researcher`, `backend`, and `planner`
+      # for `luthen-rael-planner`, whose name has two words before its role.
+      # What the screen's agent column shows, the name being too long for it.
       #
       # @return [String]
-      def role = name.split("-", 2).last.to_s
+      def role = name.split("-").last.to_s
     end
 
     # More rounds than this costs tokens and buys nothing: an agent that has

data/lib/openlanes/agents/roster.rb

@@ -27,6 +27,13 @@ module OpenLanes
       # folder by what its files justify.
       BY_CONTENTS = "by contents"
 
+      # What bb8-resolver is offered: no plan state, but the stopped rebases
+      # the harness hands it (D10). An empty cell read as "does nothing".
+      REBASES = "stopped rebases, from the harness"
+
+      # It writes, so "read-only" would be false; it moves no plan either.
+      STAGES_ONLY = "stages, never moves a plan"
+
       # @param agents [OpenLanes::Agents::Registry]
       def initialize(agents: Registry.new)
         @agents = agents
@@ -50,7 +57,7 @@ module OpenLanes
       # A state as its words alone, deliberately without the emoji that every
       # other rendering of a state carries. The table widget pads a cell to a
       # width it measures in characters, while the terminal draws a status emoji
-      # in two cells; the variation-selector ones (⭕️ 🅱️ ⚪️ ⭐️ 🕰️) are two
+      # in two cells; the variation-selector ones (⭕ 🛑 ⚪ ⭐ ⏪) are two
       # characters drawn in two cells, so no single count is right for all of
       # them. A row carrying one lands short or long and the frame stops lining
       # up. The label says the same thing unambiguously, and is worth more than
@@ -66,12 +73,17 @@ module OpenLanes
 
       # @param agent [OpenLanes::Agents::Agent]
       # @return [String]
-      def handles(agent) = agent.handles.map { |key| state(key) }.join(", ")
+      def handles(agent)
+        return REBASES if agent.name == Engine::Rebase::RESOLVER
+
+        agent.handles.map { |key| state(key) }.join(", ")
+      end
 
       # @param agent [OpenLanes::Agents::Agent]
       # @return [String]
       def advances(agent)
         return state(agent.advances_to) if agent.advances_to
+        return STAGES_ONLY if agent.name == Engine::Rebase::RESOLVER
         return BY_CONTENTS if agent.handles.any? && agent.handles.all? { |key| Plans::StateMachine::SETTLED.include?(key) }
 
         READ_ONLY

data/lib/openlanes/agents/routing.rb

@@ -16,6 +16,13 @@ module OpenLanes
       # and "no front-end units" starts nobody.
       UNIT_HEADING = /^[ \t]{0,3}\#{2,3}[ \t]+\S/
 
+      # A work unit inside a section of `plan.md`: the section is the `##`,
+      # so only a deeper heading is a unit.
+      SECTION_UNIT_HEADING = /^[ \t]{0,3}\#{3,4}[ \t]+\S/
+
+      # Any second-level heading, which ends the section before it.
+      SECTION_HEADING = /^[ \t]{0,3}\#\#[ \t]+(.+?)[ \t#]*$/
+
       module_function
 
       # @param agent [OpenLanes::Agents::Agent]
@@ -36,7 +43,7 @@ module OpenLanes
       #
       # {Agent#needs} only ever chooses between agents. When lanes and
       # switches leave one candidate, that one runs: a plan parked at 🎨 is
-      # rey-frontend's to finish whatever `plan-frontend.md` says, and an
+      # rey-frontend's to finish whatever `plan.md`'s `## Frontend` says, and an
       # operator who typed `--agent rey-frontend` meant it.
       #
       # @param agents [Array<OpenLanes::Agents::Agent>]
@@ -79,10 +86,43 @@ module OpenLanes
       # @return [Boolean]
       def reviewable?(agent, subject) = agent.phase.to_s != "review" || subject.pull_requests.any?(&:open?)
 
+      # Whether +need+ holds a work unit. A need is a file (`plan-frontend.md`)
+      # or a section of one (`plan.md#frontend`: the `## Frontend` section,
+      # matched without regard to case). Units moved into `plan.md` in plan
+      # 003; a folder planned before that still holds `plan-<section>.md`, and
+      # is read from there when `plan.md` has no such section, so no folder
+      # needs migrating.
+      #
       # @param subject [OpenLanes::Plans::Subject]
-      # @param file [String]
+      # @param need [String]
       # @return [Boolean]
-      def units?(subject, file) = Plans::Ledger.stripped(subject.read(file)).match?(UNIT_HEADING)
+      def units?(subject, need)
+        file, section = need.split("#", 2)
+        return Plans::Ledger.stripped(subject.read(file)).match?(UNIT_HEADING) unless section
+
+        body = section_of(Plans::Ledger.stripped(subject.read(file)), section)
+        return body.match?(SECTION_UNIT_HEADING) if body
+
+        units?(subject, "plan-#{section.downcase}.md")
+      end
+
+      # @param text [String]
+      # @param name [String]
+      # @return [String, nil] the lines under `## name`, up to the next `##`;
+      #   nil when there is no such heading
+      def section_of(text, name)
+        body = nil
+        text.each_line do |line|
+          if (heading = SECTION_HEADING.match(line))
+            break if body
+
+            body = +"" if heading[1].strip.casecmp?(name)
+          elsif body
+            body << line
+          end
+        end
+        body
+      end
     end
   end
 end