openlanes 3.0.0 → 3.1.0

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
@@ -131,8 +164,11 @@ module OpenLanes
           return answer_again(entry, first)
         end
 
+        # Said on the terminal and in the log: what a person asked for from
+        # 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
@@ -154,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
@@ -214,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")
@@ -234,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)
 
@@ -414,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)
@@ -424,15 +556,15 @@ module OpenLanes
           return created(made.feature, dispatcher)
         end
 
-        path = Lifecycle.create(dir: tree.dir, words: idea.split.first(8)).either(
+        path = Lifecycle.create(dir: tree.dir, words: Lifecycle::Creator.topic(idea)).either(
           ->(created) { created },
           ->(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
 
@@ -459,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)
@@ -488,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]

data/lib/openlanes/live/copilot/brief.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Live
+    class Copilot
+      # What c3po-operator is told with each message: the board as it stands,
+      # where to read further, and the person's words.
+      #
+      # The board lives in Redis, which the agent cannot read: its Bash runs
+      # only `openlanes` commands that read state, and none of them prints the
+      # live board. So the server reads the snapshot and writes it in here,
+      # fresh with every message, since the run moves between two questions.
+      # It is written as lines rather than the snapshot's JSON because the
+      # agent pays for every token of it on every message.
+      class Brief
+        # Recent log lines carried.
+        LOG_LINES = 20
+
+        # Characters of a question's body carried; the agent reads the rest
+        # from blocked.md when it needs it.
+        BODY = 400
+
+        # @param text [String] what the person typed
+        # @param board [Hash, nil] this node's `Snapshot` as parsed JSON
+        # @param others [Array<Hash>] other machines' snapshots
+        # @param plans_dir [String]
+        # @param trace_dir [String]
+        def initialize(text:, board:, plans_dir:, trace_dir:, others: [])
+          @text = text
+          @board = board
+          @others = others
+          @plans_dir = plans_dir
+          @trace_dir = trace_dir
+        end
+
+        # @return [String]
+        def to_s
+          [board, others, where, "## The person says\n\n#{@text}"].compact.join("\n\n")
+        end
+
+        private
+
+        # @return [String]
+        def board
+          return "## The board\n\nNo engine is publishing a board for this checkout: no run is going, or it has ended." unless @board
+
+          run = @board["run"] || {}
+          lines = ["## The board at #{@board["at"]}",
+                   "",
+                   "Run #{run["status"]}, #{run["agents_working"].to_i} agents working, ↑ #{run["up"].to_i} ↓ #{run["down"].to_i} tokens, " \
+                   "$#{format("%.2f", run["cost"].to_f)}."]
+          plans = Array(@board["plans"])
+          lines << (plans.empty? ? "No plans on this machine's board." : "")
+          plans.each { lines.concat(plan(it)) }
+          backlog = Array(@board["backlog"])
+          lines << "Backlog: #{backlog.map { "#{it["ordinal"]} #{it["title"]} (#{it.dig("status", "label")})" }.join("; ")}" unless backlog.empty?
+          lines.concat(log)
+          lines.join("\n")
+        end
+
+        # @param plan [Hash]
+        # @return [Array<String>]
+        def plan(plan)
+          lines = ["- #{plan["ordinal"]} #{plan["title"]}: #{plan.dig("status", "emoji")} #{plan.dig("status", "label")}, " \
+                   "#{plan["lane"]} lane, #{minutes(plan["elapsed"])} worked, $#{format("%.2f", plan["cost"].to_f)}" \
+                   "#{", PR ##{plan.dig("pr", "number")} #{plan.dig("pr", "state")}" if plan["pr"]}"]
+          Array(plan["cars"]).each { lines << car(it) }
+          Array(plan["questions"]).each { lines << question(it) }
+          if (stop = plan["interrupted"])
+            lines << "  - interrupted: #{stop["agent"]} at #{stop["at"]}: #{stop["note"]}"
+          end
+          lines
+        end
+
+        # @param car [Hash]
+        # @return [String]
+        def car(car)
+          "  - car #{car["key"]}: #{car["state"]}#{", #{car["phase"]}" if car["phase"]}, round #{car["round"]}/#{car["rounds"]}, " \
+            "#{car["model"]}, ↑ #{car["up"].to_i} ↓ #{car["down"].to_i}, #{minutes(car["elapsed"])} elapsed" \
+            "#{", #{minutes(car["remaining"])} left" if car["remaining"]}#{", held" if car["held"]}: #{car["message"].to_s.inspect}"
+        end
+
+        # @param question [Hash]
+        # @return [String]
+        def question(question)
+          body = question["body"].to_s.gsub(/\s+/, " ").strip
+          body = "#{body[0, BODY]}…" if body.length > BODY
+          "  - question #{question["id"]} (#{question["owner"]}, asked by #{question["agent"] || "unknown"}" \
+            "#{", held" if question["held"]}): #{question["heading"]}: #{body}"
+        end
+
+        # @return [Array<String>]
+        def log
+          lines = Array(@board["log"]).last(LOG_LINES)
+          return [] if lines.empty?
+
+          ["", "Recent log, newest last:"] + lines.map { "  #{it["at"]} #{it["source"]} #{it["level"]}: #{it["text"]}" }
+        end
+
+        # @return [String, nil]
+        def others
+          return nil if @others.empty?
+
+          machines = @others.map do |snapshot|
+            node = snapshot["node"] || {}
+            plans = Array(snapshot["plans"]).map { "#{it["ordinal"]} #{it.dig("status", "label")}" }
+            "- #{node["user"]}@#{node["host"]}: #{plans.empty? ? "no plans" : plans.join(", ")}"
+          end
+          "## Other machines (read only)\n\n#{machines.join("\n")}"
+        end
+
+        # @return [String]
+        def where
+          <<~TEXT.strip
+            ## Where to read more
+
+            - Plan folders: #{@plans_dir}. Each holds spec.md, plan.md, blocked.md when blocked, and state.json with its signatures and mailbox.
+            - Agents' transcripts: #{@trace_dir}, one NDJSON file per invocation, named by time, plan and agent.
+          TEXT
+        end
+
+        # @param seconds [Numeric, nil]
+        # @return [String]
+        def minutes(seconds) = "#{(seconds.to_f / 60).round}m"
+      end
+    end
+  end
+end