openlanes 3.0.1 → 3.1.0

data/lib/openlanes/live/choice_converter.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Live
+    # Rewrites a question an agent wrote as prose into D3's shape (D9): a
+    # short context paragraph and lettered options, exactly one recommended.
+    # The page draws a button per option and a text box under them, so a
+    # person can answer with one click instead of composing a reply to a
+    # paragraph.
+    #
+    # One call to a small model on OpenRouter, through `inquirex-llm`'s
+    # `OpenRouterAdapter`, which asks for a JSON object and checks that both
+    # fields came back. What the model returns is not trusted to be D3: it is
+    # cleaned, written out with {Plans::Choices.write}, and read back with
+    # {Plans::Choices.parse}, and anything that does not survive the trip is
+    # {Invalid}.
+    #
+    # It neither reads nor writes `blocked.md`; {Engine::Conversions} does,
+    # so this stays a function of text, and a seam: the suite sets
+    # {Live.choice_converter} to nil, and examples about it hand it an
+    # adapter double, so nothing in the tests reaches OpenRouter.
+    class ChoiceConverter
+      # Small and quick, and listed by OpenRouter and by inquirex-llm's own
+      # catalogue (`Models::OPENROUTER_ALIASES[:claude_haiku]`).
+      # `questions.model` in `.openlanes.yml` replaces it.
+      DEFAULT_MODEL = "anthropic/claude-haiku-5.5"
+
+      # What the model reads with the question.
+      PROMPT = <<~PROMPT
+        A software agent stopped and wrote the question below for a person. The person answers it in a
+        web page that shows one button per option and a free-text box under them. Rewrite the question as
+        multiple choice:
+
+        - `context`: one short paragraph with what the person needs to know to choose. Keep every fact,
+          number and name that matters; drop repetition. Do not repeat the heading.
+        - `options`: an array of 2 to 5 objects `{"label": String, "recommended": Boolean}`, each a distinct
+          answer the question already implies, written as one short line in the agent's own terms.
+          Exactly one has `"recommended": true`: the one the question itself prefers, or, if it prefers
+          none, the safest one.
+
+        Never change what is being asked, never add facts the question does not state, never answer it,
+        and never add an option for "something else" or "type something instead": the page has a text box.
+      PROMPT
+
+      # What the model answered could not be made into a D3 question.
+      class Invalid < Error; end
+
+      # @!attribute [r] body
+      #   @return [String] the question's new body, D3-shaped Markdown
+      # @!attribute [r] count
+      #   @return [Integer] how many options it offers
+      # @!attribute [r] model
+      #   @return [String] the model that wrote it
+      Result = Data.define(:body, :count, :model)
+
+      # A converter when OPENROUTER_API_KEY is set, nil otherwise.
+      #
+      # @param env [#[]]
+      # @param config [OpenLanes::Config]
+      # @return [OpenLanes::Live::ChoiceConverter, nil]
+      def self.from_env(env = ENV, config: Config.current)
+        key = env["OPENROUTER_API_KEY"].to_s.strip
+        key.empty? ? nil : new(api_key: key, model: config.questions_model || DEFAULT_MODEL)
+      end
+
+      # The model's answer, cleaned and written in D3's shape.
+      #
+      # @param output [Hash] `context` and `options`, as the adapter parsed them
+      # @return [String] the new body
+      # @raise [Invalid] when it cannot be one
+      def self.render(output)
+        output = output.to_h.transform_keys(&:to_sym)
+        context = output[:context].to_s.strip
+        raise Invalid, "no context" if context.empty?
+        # A heading inside the body would end the question there, and a
+        # `Bn` or `An` line would start another one.
+        if [Plans::BlockedFile::HEADING, Plans::OPEN_BLOCK, Plans::ANSWER_BLOCK].any? { context.match?(it) }
+          raise Invalid, "the context holds a heading"
+        end
+
+        options = Array(output[:options]).map { option(it) }
+                                         .reject { |label, _| label.match?(Plans::Choices::SOMETHING_ELSE) }
+        raise Invalid, "#{options.size} option#{"s" unless options.size == 1}, not 2 or more" if options.size < 2
+
+        recommended = options.each_index.select { options[it].last }
+        raise Invalid, "#{recommended.size} options recommended, not one" unless recommended.size == 1
+
+        body = Plans::Choices.write(context:, labels: options.map(&:first), recommended: recommended.first)
+        back = Plans::Choices.parse(body)
+        raise Invalid, "the rewrite does not read back as #{options.size} choices" unless back&.options&.size == options.size
+
+        body
+      end
+
+      # One option as a label on one line and whether it is recommended; a
+      # recommendation the model wrote into the label is taken out of it, since
+      # the flag already says so.
+      #
+      # @param raw [Hash, Object]
+      # @return [Array(String, Boolean)]
+      # @raise [Invalid]
+      def self.option(raw)
+        raise Invalid, "an option is not an object" unless raw.is_a?(Hash)
+
+        raw = raw.transform_keys(&:to_sym)
+        label = raw[:label].to_s.gsub(/\s+/, " ").sub(Plans::Choices::RECOMMENDED, " ").strip
+        raise Invalid, "an option has no label" if label.empty?
+
+        [label, [true, "true"].include?(raw[:recommended])]
+      end
+      private_class_method :option
+
+      # @param api_key [String, nil] OpenRouter's; only read to build the default adapter
+      # @param model [String] an OpenRouter model id
+      # @param adapter [#call, nil] answers `call(node, answers)` with a Hash
+      #   holding `context` and `options`, as `Inquirex::LLM::OpenRouterAdapter`
+      #   does; built on first use when nil, so a process that never converts
+      #   never loads inquirex
+      def initialize(api_key: nil, model: DEFAULT_MODEL, adapter: nil)
+        @api_key = api_key
+        @model = model
+        @adapter = adapter
+        @mutex = Mutex.new
+      end
+
+      # @return [String]
+      attr_reader :model
+
+      # Blocks for as long as the request takes (the adapter gives up after
+      # 30 seconds without an answer), so the engine calls it on a thread.
+      #
+      # @param heading [String] the question's heading, for context; it is kept
+      # @param body [String] the question as the agent wrote it
+      # @return [OpenLanes::Live::ChoiceConverter::Result]
+      # @raise [Invalid] when the answer is not a D3 question
+      # @raise [StandardError] whatever the adapter raises: no network, a 4xx, bad JSON
+      def call(heading:, body:)
+        output = adapter.call(node, { heading: heading.to_s, question: body.to_s })
+        written = self.class.render(output)
+        Result.new(body: written, count: Plans::Choices.parse(written).options.size, model:)
+      end
+
+      private
+
+      def adapter
+        @mutex.synchronize do
+          @adapter ||= begin
+            require "inquirex-llm"
+            Inquirex::LLM::OpenRouterAdapter.new(api_key: @api_key, model:)
+          end
+        end
+      end
+
+      def node
+        @node ||= begin
+          require "inquirex-llm"
+          Inquirex::LLM::Node.new(id: :choices,
+            verb: :extract,
+            prompt: PROMPT,
+            schema: Inquirex::LLM::Schema.new(context: :string, options: :array),
+            from_steps: %i[heading question])
+        end
+      end
+    end
+  end
+end

data/lib/openlanes/live/choice_judge.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module OpenLanes
+  module Live
+    # A second opinion on {Plans::Choices}: does this message ask its reader
+    # to choose one of the options it lists? Asked of Jev, TypeSafe's System
+    # One model, through `inquirex-llm`'s `JevAdapter`, as one boolean.
+    #
+    # The parser cannot tell "Done so far: 1. … 2. …" from a numbered choice;
+    # Jev can. Its answer only ever narrows: `false` takes the buttons away and
+    # leaves the text box, `true` keeps them, and `nil` (no answer, an error, a
+    # timeout, an answer too unsure to count) leaves the parser's verdict as it
+    # was. A missing key therefore costs nothing but the second opinion.
+    #
+    # The snapshot is rebuilt every time the board moves, so every answer is
+    # kept, in this process, by the SHA256 of the text: one request per
+    # distinct question, ever. A request still in flight when {#call} gives up
+    # waiting goes on in its thread, and the next snapshot finds its answer.
+    #
+    # A seam, like {Vcs::GitHub} and {Linear::API}: the suite sets
+    # {Live.choice_judge} to nil, and examples about the judge hand it an
+    # adapter double, so nothing in the tests reaches TypeSafe.
+    class ChoiceJudge
+      # What Jev reads with the message. Its boolean question is whether
+      # `asks_to_choose` is true according to the message.
+      PROMPT = <<~PROMPT
+        The message below was written by a software agent to a person, who answers it in a web page.
+        `asks_to_choose` is true when the message asks the person to pick one of the options it lists
+        (lettered or numbered alternatives, or a plain yes/no question), and false when the list is
+        something else: steps already done, findings, a plan, or a question that wants a written answer.
+      PROMPT
+
+      # How long a snapshot waits for an answer it does not have yet.
+      TIMEOUT = 3.0
+
+      # Below this Jev is guessing, and the parser's verdict stands.
+      MIN_CONFIDENCE = 0.6
+
+      # The schema field Jev answers.
+      FIELD = :asks_to_choose
+
+      # A judge when TYPESAFE_API_KEY is set, nil otherwise.
+      #
+      # @param env [#[]]
+      # @return [OpenLanes::Live::ChoiceJudge, nil]
+      def self.from_env(env = ENV)
+        key = env["TYPESAFE_API_KEY"].to_s.strip
+        key.empty? ? nil : new(api_key: key)
+      end
+
+      # @param api_key [String, nil] TypeSafe's; only read to build the default adapter
+      # @param adapter [#call, nil] answers `call(node, answers)` with a Hash
+      #   holding {FIELD}, as `Inquirex::LLM::JevAdapter` does; built on first
+      #   use when nil, so a process that never judges never loads inquirex
+      # @param timeout [Float] seconds {#call} waits for an answer it lacks
+      def initialize(api_key: nil, adapter: nil, timeout: TIMEOUT)
+        @api_key = api_key
+        @adapter = adapter
+        @timeout = timeout
+        @answers = {}
+        @mutex = Mutex.new
+      end
+
+      # @param text [String] the question, as the person would read it
+      # @return [Boolean, nil] whether it asks to choose; nil when Jev has not
+      #   said, or could not
+      def call(text)
+        key = Digest::SHA256.hexdigest(text.to_s)
+        asking = @mutex.synchronize { @answers[key] ||= ask(text.to_s) }
+        asking.join(@timeout) ? asking.value : nil
+      end
+
+      private
+
+      # @return [Thread] whose value is true, false or nil
+      def ask(text)
+        Thread.new do
+          Thread.current.report_on_exception = false
+          adapter.call(node, { message: text })[FIELD]
+        rescue StandardError => e
+          UI.log("choice judge: no verdict (#{e.class})")
+          nil
+        end
+      end
+
+      def adapter
+        @mutex.synchronize do
+          @adapter ||= begin
+            require "inquirex-llm"
+            Inquirex::LLM::JevAdapter.new(api_key: @api_key, min_confidence: MIN_CONFIDENCE)
+          end
+        end
+      end
+
+      def node
+        @node ||= begin
+          require "inquirex-llm"
+          Inquirex::LLM::Node.new(id: :choice,
+            verb: :extract,
+            prompt: PROMPT,
+            schema: Inquirex::LLM::Schema.new(FIELD => :boolean),
+            from_steps: [:message])
+        end
+      end
+    end
+  end
+end

data/lib/openlanes/live/claims.rb

@@ -39,9 +39,17 @@ module OpenLanes
       # Extend every claim this node holds. One that lapsed and was taken by
       # another node in the meantime is dropped from {#held}, not fought for.
       #
+      # One that is simply gone is taken back: a Redis that restarted empty
+      # (W32) has lost every claim, and reading that as "another machine
+      # took it" stopped this machine's own agents for plans nobody else
+      # wanted. `SET NX` still loses to a node that got there first.
+      #
       # @return [Array<String>] the ordinals lost
       def renew
-        lost = held.reject { |ordinal| @store.compare_and_expire(@keys.claim(ordinal), @keys.node, @ttl) }
+        lost = held.reject do |ordinal|
+          key = @keys.claim(ordinal)
+          @store.compare_and_expire(key, @keys.node, @ttl) || @store.set(key, @keys.node, ex: @ttl, nx: true)
+        end
         @mutex.synchronize { @held -= lost }
         lost
       end

data/lib/openlanes/live/command.rb

@@ -42,25 +42,28 @@ module OpenLanes
 
       # Every kind the page may send.
       KINDS = %w[answer hold_blocked release_hold resume discard message hold wrap_up compact stop stop_all
-                 set_model switch_model add_plan create_plans].freeze
+                 set_model switch_model add_plan create_plans respond pause_discuss resume_anyway
+                 stop_plan restart_plan set_concurrency].freeze
 
       # Kinds that act on one plan, and so must name it.
       PLAN_KINDS = %w[answer hold_blocked release_hold resume discard message hold wrap_up compact stop
-                      set_model switch_model].freeze
+                      set_model switch_model respond pause_discuss resume_anyway stop_plan restart_plan].freeze
 
       # Kinds that act on one agent of that plan, and so must name it too.
       AGENT_KINDS = %w[hold wrap_up compact stop set_model switch_model].freeze
 
       # Payload fields each kind cannot do without.
       PAYLOAD = {
-        "answer"       => %w[question text],
-        "hold_blocked" => %w[question],
-        "release_hold" => %w[question],
-        "message"      => %w[text],
-        "set_model"    => %w[model],
-        "switch_model" => %w[model],
-        "add_plan"     => %w[ordinal],
-        "create_plans" => %w[idea]
+        "answer"          => %w[question text],
+        "hold_blocked"    => %w[question],
+        "release_hold"    => %w[question],
+        "message"         => %w[text],
+        "set_model"       => %w[model],
+        "switch_model"    => %w[model],
+        "add_plan"        => %w[ordinal],
+        "create_plans"    => %w[idea],
+        "respond"         => %w[text],
+        "set_concurrency" => %w[limit]
       }.freeze
 
       # Ids are ULIDs; this only keeps an absurd one out of a hash field.

data/lib/openlanes/live/commands.rb

@@ -31,26 +31,49 @@ module OpenLanes
 
       # Command kind to the method that applies it.
       HANDLERS = {
-        "answer"       => :answer,
-        "hold_blocked" => :hold_blocked,
-        "release_hold" => :release_hold,
-        "resume"       => :resume,
-        "discard"      => :discard,
-        "message"      => :message,
-        "hold"         => :signal,
-        "wrap_up"      => :signal,
-        "compact"      => :compact,
-        "stop"         => :signal,
-        "stop_all"     => :stop_all,
-        "set_model"    => :set_model,
-        "switch_model" => :switch_model,
-        "add_plan"     => :add_plan,
-        "create_plans" => :create_plans
+        "answer"          => :answer,
+        "hold_blocked"    => :hold_blocked,
+        "release_hold"    => :release_hold,
+        "resume"          => :resume,
+        "discard"         => :discard,
+        "message"         => :message,
+        "hold"            => :signal,
+        "wrap_up"         => :signal,
+        "compact"         => :compact,
+        "stop"            => :signal,
+        "stop_all"        => :stop_all,
+        "set_model"       => :set_model,
+        "switch_model"    => :switch_model,
+        "add_plan"        => :add_plan,
+        "create_plans"    => :create_plans,
+        "respond"         => :respond,
+        "pause_discuss"   => :pause_discuss,
+        "resume_anyway"   => :resume_anyway,
+        "stop_plan"       => :stop_plan,
+        "restart_plan"    => :restart_plan,
+        "set_concurrency" => :set_concurrency
       }.freeze
 
+      # How long "Resume anyway" lifts a 💣's halt.
+      RESUME_FOR = 24 * 3600
+
       # Plans a person may not add to a run: there is nothing left to do.
       FINISHED = Snapshot::FINISHED
 
+      # The copilot turn that answers a slash command: `"<id>.1"`, the turn
+      # the page's "reading" waits for. {Web::Demo} writes the same one, so
+      # the demo's copilot ends its wait as the engine's does.
+      #
+      # @param reply [OpenLanes::Live::Reply]
+      # @return [OpenLanes::Live::Copilot::Turn]
+      def self.echo_turn(reply)
+        Copilot::Turn.new(id: "#{reply.id}.1",
+          from: "copilot",
+          kind: "text",
+          text: [reply.status, reply.reason].compact.join(": "),
+          at: reply.at)
+      end
+
       # @param store [OpenLanes::Live::Store, OpenLanes::Live::MemoryStore]
       # @param keys [OpenLanes::Live::Keys]
       # @param node [OpenLanes::Live::Node]
@@ -106,9 +129,19 @@ module OpenLanes
         @ready = true
       end
 
+      # A group that went with a Redis restarted empty is made again, and
+      # the read tried once more; that it vanished once is no reason to stop
+      # the engine, as it did (#59).
+      #
       # @param id [String] "0" for this consumer's pending, ">" for new
       # @return [Array<OpenLanes::Live::Store::Entry>]
-      def read(id) = @store.xreadgroup(@keys.commands, Keys::GROUP, @node.name, id:, count: BATCH)
+      def read(id)
+        @store.xreadgroup(@keys.commands, Keys::GROUP, @node.name, id:, count: BATCH)
+      rescue GroupMissing
+        @ready = false
+        prepare
+        @store.xreadgroup(@keys.commands, Keys::GROUP, @node.name, id:, count: BATCH)
+      end
 
       # Answer the commands whose work finished since the last tick. A
       # command still at work is neither answered nor acknowledged, so an
@@ -135,7 +168,7 @@ module OpenLanes
         # the page is part of the run's story, beside what the agents did.
         UI.log("from the page: #{command.kind.tr("_", " ")}", **{ plan: command.plan, agent: command.agent }.compact)
         status, reason = apply(command, dispatcher)
-        return reply(entry, command.id, status, reason) unless status == :pending
+        return reply(entry, command.id, status, reason, echo: command.payload["source"] == "copilot") unless status == :pending
 
         @pending[entry.id] = [entry, command.id, reason]
         nil
@@ -157,25 +190,36 @@ module OpenLanes
         ["refused", "#{command.kind} failed: #{e.message}"]
       end
 
+      # A command the copilot sent (a slash command, plan 020.00) is also
+      # answered in the conversation, as turn `"<id>.1"`: that is the turn the
+      # page's "reading" waits for, and the conversation keeps the outcome.
+      # It is written in the same `MULTI`, so a redelivery, which
+      # {#answer_again} handles, can never write it twice.
+      #
+      # @param echo [Boolean] whether to answer in the copilot stream too
       # @return [OpenLanes::Live::Reply]
-      def reply(entry, id, status, reason)
+      def reply(entry, id, status, reason, echo: false)
         reply = Reply.new(id:, status:, reason:, at: @clock.call)
         json = reply.to_json
-        @store.multi do |tx|
+        turn = Commands.echo_turn(reply) if echo
+        EventBus.for(@store).transaction do |tx|
           tx.hset(@keys.done, id, json)
-          tx.xadd(@keys.replies, { json: }, maxlen: Keys::REPLIES_LENGTH)
+          tx.append(@keys.replies, { json: }, maxlen: Keys::REPLIES_LENGTH)
+          tx.append(@keys.copilot, { json: turn.to_json }, maxlen: Keys::COPILOT_LENGTH) if turn
           tx.xack(@keys.commands, Keys::GROUP, entry.id)
           @record&.write(tx)
         end
+        News.publish(store: @store, keys: @keys, kind: "reply")
         reply
       end
 
       # @return [OpenLanes::Live::Reply] the first reply, sent again
       def answer_again(entry, first)
-        @store.multi do |tx|
-          tx.xadd(@keys.replies, { json: first }, maxlen: Keys::REPLIES_LENGTH)
+        EventBus.for(@store).transaction do |tx|
+          tx.append(@keys.replies, { json: first }, maxlen: Keys::REPLIES_LENGTH)
           tx.xack(@keys.commands, Keys::GROUP, entry.id)
         end
+        News.publish(store: @store, keys: @keys, kind: "reply")
         data = JSON.parse(first)
         Reply.new(id: data["id"], status: data["status"], reason: data["reason"], at: Time.iso8601(data["at"]))
       end
@@ -217,17 +261,25 @@ module OpenLanes
 
       # `## A<n>` under the question, signed, for `lando-broker` to fold in
       # (W10). The dispatcher hands the plan to the broker once every
-      # question has an answer, and the plan leaves ⭕️ when the file is
+      # question has an answer, and the plan leaves ⭕ when the file is
       # drained. The answer carries the command's id in a comment, so a
       # command applied again after a crash finds it and writes nothing.
       #
       # @return [String, nil]
       def answer(command, dispatcher)
+        return extension(command, dispatcher) if command["question"].to_s.match?(/\AX\d+\z/i)
+        return quality(command, dispatcher) if command["question"].to_s.casecmp?(Engine::QualityQuestion::NAME)
+
         subject, question = question!(command, dispatcher)
-        path = File.join(subject.feature.path, "blocked.md")
-        return nil if File.read(path).include?(marker(command))
+        return nil if File.read(File.join(subject.feature.path, "blocked.md")).include?(marker(command))
         return "B#{question.number} already has an answer waiting" if question.answered
 
+        write_answer(subject, question, command, dispatcher)
+      end
+
+      # @return [nil]
+      def write_answer(subject, question, command, dispatcher)
+        path = File.join(subject.feature.path, "blocked.md")
         File.open(path, "a") do |file|
           file.write("\n## A#{question.number}\n\n#{command["text"]}\n\n" \
                      "Answered by #{@node.user} on #{@clock.call.strftime("%Y-%m-%d")}\n#{marker(command)}\n")
@@ -237,6 +289,83 @@ module OpenLanes
         nil
       end
 
+      # An answer to the harness's request for more time or rounds (E1).
+      # The page sends the chosen option, "b) Extend Time by 10 minutes";
+      # only its letter counts, so there is nothing to parse but that.
+      #
+      # @return [String]
+      def extension(command, dispatcher)
+        subject = subject!(command, dispatcher)
+        number = command["question"][1..].to_i
+        letter = command["text"].to_s.strip[/\A([a-c])\)?(?:\s|\z)/i, 1] or
+          raise Refusal, "X#{number} takes a), b) or c), not #{command["text"].to_s.strip[0, 40].inspect}"
+        settled = dispatcher.answer_extension(subject, number, letter.downcase, by: @node.user) or
+          raise Refusal, "#{command.plan} has no open request X#{number}"
+        settled["grant"] == "live" ? "#{settled["agent"]} has #{settled["seconds"] / 60} more minutes" : "#{settled["agent"]} gets one more round"
+      end
+
+      # R4's answer: a) high or b) mvp, written into `.openlanes.yml` (U3).
+      # Only the letter counts, as for {#extension}.
+      #
+      # @return [String]
+      def quality(command, dispatcher)
+        subject = subject!(command, dispatcher)
+        name = Engine::QualityQuestion::NAME
+        letter = command["text"].to_s.strip[/\A([ab])\)?(?:\s|\z)/i, 1] or
+          raise Refusal, "#{name} takes a) or b), not #{command["text"].to_s.strip[0, 40].inspect}"
+        chosen = Engine::QualityQuestion.answer!(subject.feature.path, letter, by: @node.user, root: File.dirname(dispatcher.runner.tree.dir)) or
+          raise Refusal, "#{command.plan} has no open question #{name}"
+        dispatcher.wake!
+        "desired_codebase_quality: #{chosen} in #{Config::FILE}"
+      end
+
+      # ---- bombs ------------------------------------------------------------
+
+      # The 💣 notice's answer box (plan 009): the first open question with
+      # no answer yet gets this one, in exactly the form {#answer} writes,
+      # so the drain that clears a ⭕ clears the 💣 too.
+      #
+      # @return [String, nil]
+      def respond(command, dispatcher)
+        subject = bomb!(command, dispatcher)
+        return nil if File.read(File.join(subject.feature.path, "blocked.md")).include?(marker(command))
+
+        question = Lifecycle::Unblocker.questions(subject).reject(&:answered).first or
+          raise Refusal, "every question #{command.plan} asks already has an answer waiting"
+        write_answer(subject, question, command, dispatcher)
+        "answered B#{question.number}"
+      end
+
+      # Pause and Discuss (N10): every agent on this machine holds, and the
+      # page opens the copilot on the plan. No file changes.
+      #
+      # @return [String]
+      def pause_discuss(command, dispatcher)
+        bomb!(command, dispatcher)
+        held = dispatcher.running.map(&:key).select { dispatcher.signal(it, Execution::Control::HOLD) }
+        held.each { @run_state.hold_car(it, held: true) }
+        "held #{held.size} agent#{"s" unless held.size == 1}; discuss #{command.plan} in the copilot"
+      end
+
+      # Resume anyway for {RESUME_FOR}: the halt this 💣 causes lapses on its
+      # own, with no config edit to undo.
+      #
+      # @return [String]
+      def resume_anyway(command, dispatcher)
+        subject = bomb!(command, dispatcher)
+        till = Plans::PlanState.for(subject.feature.path).resume_anyway!(till: @clock.call + RESUME_FOR)
+        dispatcher.wake!
+        "#{command.plan} halts nothing until #{till.utc.iso8601}"
+      end
+
+      # @return [OpenLanes::Plans::Subject] the plan, refused unless it is 💣
+      def bomb!(command, dispatcher)
+        subject = subject!(command, dispatcher)
+        raise Refusal, "#{command.plan} is #{subject.status}, not a 💣" unless subject.status.key == :bomb
+
+        subject
+      end
+
       # @return [nil]
       def hold_blocked(command, dispatcher) = hold_question(command, dispatcher, held: true)
 
@@ -417,7 +546,7 @@ module OpenLanes
         nil
       end
 
-      # The idea becomes a ⚪️ plan whose spec.md opens with it, then joins the run.
+      # The idea becomes a ⚪ plan whose spec.md opens with it, then joins the run.
       #
       # @return [String]
       def create_plans(command, dispatcher)
@@ -432,10 +561,10 @@ module OpenLanes
           ->(problem) { raise Refusal, "could not create the plan: #{problem}" }
         )
         feature = Plans::Feature.parse(path)
-        spec = Lifecycle.brief(path:, title: feature.title, root: File.dirname(tree.dir), seed: "#{idea}\n\n#{marker(command)}")
-                        .write_scaffold!
-        settings = idea_frontmatter(command.payload["frontmatter"])
-        File.write(spec, "#{YAML.dump(settings)}---\n\n#{File.read(spec)}") unless settings.empty?
+        seed = [idea, decisions(command.payload["decisions"]), marker(command)].compact.join("\n\n")
+        brief = Lifecycle.brief(path:, title: feature.title, root: File.dirname(tree.dir), seed:)
+        brief.write_scaffold!
+        brief.stamp!(idea_frontmatter(command.payload["frontmatter"]))
         created(feature, dispatcher)
       end
 
@@ -462,6 +591,22 @@ module OpenLanes
         end
       end
 
+      # The interview's answers (M6) as a `## Decisions` section of the
+      # spec, so the agents downstream find them made instead of blocking to
+      # ask. A skipped interview sends none, and the spec is as it was.
+      #
+      # @param list [Array<Hash>, nil] `payload.decisions`: `question`, `answer`
+      # @return [String, nil]
+      def decisions(list)
+        rows = Array(list).filter_map do |entry|
+          next unless entry.is_a?(Hash)
+
+          question, answer = entry.transform_keys(&:to_s).values_at("question", "answer").map { it.to_s.gsub(/\s+/, " ").strip }
+          "- **#{question}** #{answer}" unless question.empty? || answer.empty?
+        end
+        "## Decisions\n\n#{rows.join("\n")}" unless rows.empty?
+      end
+
       # @return [String]
       def created(feature, dispatcher)
         claim!(feature.ordinal)
@@ -491,6 +636,48 @@ module OpenLanes
         json ? JSON.parse(json).values_at("user", "host").join("@") : "another machine"
       end
 
+      # ---- lanes (plan 020.00) ----------------------------------------------
+
+      # `/stop NNN`: every agent on the plan stops, and the plan leaves the board.
+      #
+      # @return [String]
+      def stop_plan(command, dispatcher)
+        ordinal = ordinal!(command)
+        told = dispatcher.stop_plan(ordinal)
+        told.each { @run_state.hold_car(it, held: false) }
+        "stopped #{told.size} agent#{"s" unless told.size == 1} on #{ordinal} and took it off the board"
+      end
+
+      # `/restart NNN`: a lane that lost its agent is dispatched again.
+      #
+      # @return [String]
+      def restart_plan(command, dispatcher)
+        ordinal = ordinal!(command)
+        dispatcher.restart_plan(ordinal)
+        "#{ordinal} restarts at the next tick"
+      end
+
+      # `/concurrency N`. Lowering it stops nobody; the run waits for agents
+      # to finish until it is under the new limit.
+      #
+      # @return [String]
+      def set_concurrency(command, dispatcher)
+        limit = command.payload["limit"]
+        raise Refusal, "concurrency must be a whole number of at least 1, not #{limit.inspect}" unless limit.is_a?(Integer) && limit >= 1
+
+        before = dispatcher.runner.jobs
+        dispatcher.concurrency = limit
+        @run_state.concurrency = limit
+        over = dispatcher.running.size - limit
+        wait = over.positive? ? "; the run waits for #{over} agent#{"s" unless over == 1} to finish" : ""
+        "concurrency #{before} → #{limit}#{wait}"
+      end
+
+      # @return [String] the plan's ordinal, normalised
+      def ordinal!(command)
+        (Plans::Ordinal.parse(command.plan.to_s) or raise Refusal, "#{command.plan} is not a plan number").to_s
+      end
+
       # ---- lookups ----------------------------------------------------------
 
       # @return [OpenLanes::Plans::Subject]