hecks 6.0.0 → 7.0.0

data/lib/hecks/quality_control/cli/qa_domain_novelty.rb

@@ -99,14 +99,14 @@ module Hecks
         [argv.first(split), argv.drop(split + 1).reject { |arg| arg == "--against" }]
       end
 
-      # `hecks project_rust` reads exactly `<name>/bluebook/<name>.bluebook`, so refuse anything
+      # `hecks build.project_rust!` reads exactly `<name>/bluebook/<name>.bluebook`, so refuse anything
       # else early.
       def refuse_unless_stress_domain_shaped!(path)
         expected = File.join(path, "bluebook", "#{File.basename(path)}.bluebook")
         return if File.file?(expected)
 
         raise UsageError, "#{path} is not shaped like a stress domain: expected #{expected} to exist " \
-                          "(`<name>/bluebook/<name>.bluebook` — a flat file breaks `hecks project_rust`; " \
+                          "(`<name>/bluebook/<name>.bluebook` — a flat file breaks `hecks build.project_rust!`; " \
                           "see qa/stress_domains/ledger_ordering/NOTES.md)"
       end
 
@@ -121,7 +121,7 @@ module Hecks
           raise Stopped
         end
 
-        JSON.parse(out).map { |row| row.dig("path", "value") }.compact
+        JSON.parse(out).filter_map { |row| row["path"] }
       end
 
       def normalize(path) = File.expand_path(path, @root)

data/lib/hecks/quality_control/cli/qa_event_pump/attached.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaEventPump
+      # The domains the pump reads and reacts for: each name with the directory that boots it. The
+      # ledger, `QualityControl`, is the one whose `EventCursor` rows hold the positions.
+      class Attached
+        # @param root [String] the repository root the default directories are found under
+        # @param env [Hash{String => String}] `QA_SWEEP_DOMAIN_DIR` overrides the ledger's directory
+        # @param dirs [Hash{String => String}, nil] the directories by domain name, in place of the
+        #   defaults
+        def initialize(root:, env: ENV, dirs: nil)
+          @dirs = dirs || default_dirs(root, env)
+          @runtimes = {}
+        end
+
+        # @return [Array<String>] the attached domain names, in the order the pump visits them
+        def names = @dirs.keys
+
+        # @param name [String] a domain name
+        # @return [Boolean] whether the pump attaches this domain
+        def known?(name) = @dirs.key?(name)
+
+        # @return [Array<Hecks::Registry>] the registries of every domain booted so far this run
+        def registries = @runtimes.values.map(&:registry)
+
+        # @param name [String] an attached domain name
+        # @return [String] the directory that boots it
+        def dir(name) = @dirs.fetch(name)
+
+        # @param name [String] an attached domain name
+        # @return [Hecks::Runtime::Dispatcher] the domain booted once, and kept for the run
+        def runtime(name)
+          @runtimes[name] ||= Hecks.boot(dir(name))
+        end
+
+        # Whether a domain booted in this process has already delivered `policy` for `event`. The
+        # reaction log keeps the event id each reaction answered, so a second run of the same event
+        # in this process is skipped whatever the cursor says.
+        #
+        # @param event [Hecks::Runtime::Event] the event, with its id
+        # @param policy [Hecks::Bluebook::Policy] the policy about to run
+        # @return [Boolean] true when a delivered reaction for this event and policy is logged
+        def reacted?(event, policy)
+          registries.any? do |registry|
+            registry.reaction_log.any? do |record|
+              record[:delivered] && record[:policy] == policy.name && record[:on] == event.name &&
+                registry.reaction_event(record) == event.id
+            end
+          end
+        end
+
+        private
+
+        def default_dirs(root, env)
+          {
+            "QualityControl" => env.fetch("QA_SWEEP_DOMAIN_DIR", File.join(root, "qa/bluebook")),
+            "Fixer"          => File.join(root, "lib/hecks/fixer"),
+            "Coder"          => File.join(root, "lib/hecks/coder"),
+            "CiPipeline"     => File.join(root, "lib/hecks/ci_pipeline")
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_event_pump/consumer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "hecks/naming"
+
+module Hecks
+  module QualityControlCli
+    class QaEventPump
+      # One attached domain as a consumer: the logs of the domains its hecksagon subscribes to, read
+      # past each cursor, with the policies that react to each event run through the domain's own
+      # runtime. A subscription to a domain the pump does not attach is named, not read.
+      class Consumer
+        # @param name [String] the consumer's domain name
+        # @param attached [Attached] the attached domains
+        # @param cursors [Cursors] where the positions are kept
+        # @param reactions [Reactions] where the reactions already made are kept
+        def initialize(name, attached:, cursors:, reactions:)
+          @name = name
+          @attached = attached
+          @cursors = cursors
+          @reactions = reactions
+          @failed = false
+        end
+
+        # @return [Boolean] whether reading or reacting stopped this consumer
+        def failed? = @failed
+
+        # Reads every attached log this consumer subscribes to, and names each subscription it
+        # cannot read.
+        #
+        # @return [Array<String>] one line per reaction and per problem
+        def lines
+          producers.flat_map { |producer| read(producer) } + unattached
+        end
+
+        private
+
+        def runtime = @attached.runtime(@name)
+
+        def subscribed
+          (runtime.registry.hecksagon(@name)&.subscriptions || []).filter_map { |event| Naming.qualifier(event) }.uniq
+        end
+
+        def producers = subscribed.select { |domain| @attached.known?(domain) }
+
+        def unattached
+          (subscribed - producers).map { |domain| "#{@name} subscribes to #{domain}, which the pump does not attach" }
+        end
+
+        # Reads one producer's log past this consumer's cursor, reacting to each entry in turn. A
+        # stop leaves the cursor on the last entry that was reacted to.
+        def read(producer)
+          start = @cursors.position(producer, @name)
+          entries = Reader.after(@attached.dir(producer), start)[:events]
+          entries.each_with_index.flat_map { |entry, index| react(producer, entry, start + index + 1) }
+        rescue StandardError => e
+          @failed = true
+          ["#{@name} <- #{producer}: stopped, #{e.class}: #{e.message}"]
+        end
+
+        # Runs each policy that reacts to the entry and that neither the ledger nor this process
+        # holds a reaction for, then moves the cursor past it. A reaction is recorded as soon as
+        # its policy answers, before the cursor moves. The reactions and the cursor share one
+        # transaction where the ledger's store has one, so a stop between them rolls both back
+        # and the rerun repeats both.
+        def react(producer, entry, position)
+          event = Reader.event(entry)
+          @cursors.transaction do
+            lines = runtime.outbox.policies_for(event, producer).flat_map do |policy, home|
+              next [] if reacted?(event, policy)
+
+              fire(event, policy, home, producer, position)
+            end
+            @cursors.advance(producer, @name, position)
+            lines
+          end
+        end
+
+        # Whether the policy has already reacted to this event: recorded in the ledger by an
+        # earlier pass, or delivered in this process by a domain attached here, by either path.
+        def reacted?(event, policy)
+          @reactions.recorded?(@name, event.id, policy.name) || @attached.reacted?(event, policy)
+        end
+
+        def fire(event, policy, home, producer, position)
+          log = runtime.reactions
+          before = log.size
+          runtime.outbox.react_policy(event, policy: policy, home: home, domain: producer,
+                                             event_uid: "#{producer}##{position}")
+          records = log.drop(before)
+          @reactions.record(@name, event.id, policy.name) if records.any?
+          records.map { |record| describe(record, policy, event, producer) }
+        end
+
+        def describe(record, policy, event, producer)
+          label = "#{@name} <- #{producer} #{event.name}: #{policy.name}"
+          return "reacted: #{label}" if record[:delivered]
+
+          "refused: #{label}: #{record[:reason]}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_event_pump/cursors.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaEventPump
+      # The positions the pump has read to, kept as the ledger's `EventCursor` rows: one per (log,
+      # consumer). A row is opened at the start of the log the first time a consumer reads it.
+      class Cursors
+        # @param runtime [Hecks::Runtime::Dispatcher] the booted ledger the rows live in
+        def initialize(runtime)
+          @runtime = runtime
+        end
+
+        # @param log [String] the domain whose event log is read
+        # @param consumer [String] the domain whose policies react
+        # @return [Integer] the count of log entries the consumer has reacted to
+        def position(log, consumer)
+          row = row_for(key(log, consumer)) || open_row(log, consumer)
+          row[:position][:value]
+        end
+
+        # Moves one consumer's cursor past the entries it has reacted to.
+        #
+        # @param log [String] the domain whose event log was read
+        # @param consumer [String] the domain whose policies reacted
+        # @param position [Integer] the count of entries now reacted to
+        # @return [void]
+        def advance(log, consumer, position)
+          @runtime.dispatch_flat("QualityControl::EventCursor.Advance", to: key(log, consumer), position: position)
+        end
+
+        # Runs the block in one transaction on the ledger's store where that store has one, so a
+        # reaction and the cursor past it commit together or not at all. A store without
+        # transactions (Memory) yields, and the reaction log is then the only guard against a rerun.
+        #
+        # @yield the reaction and the cursor move, as one unit
+        # @return [Object] the block's own value
+        def transaction(&)
+          repository = @runtime.registry.repository("QualityControl", cursor_aggregate)
+          repository.respond_to?(:transaction) ? repository.transaction(&) : yield
+        end
+
+        private
+
+        def cursor_aggregate = ledger_bluebook.aggregates.find { |aggregate| aggregate.hecks_name == "EventCursor" }
+
+        def ledger_bluebook = @runtime.registry.bluebook("QualityControl")
+
+        def key(log, consumer) = "#{log}/#{consumer}"
+
+        def row_for(key) = @runtime.query("QualityControl::EventCursor.All").find { |row| row[:key][:value] == key }
+
+        def open_row(log, consumer)
+          @runtime.dispatch_flat("QualityControl::EventCursor.Start", key: key(log, consumer), log: log, consumer: consumer)
+          row_for(key(log, consumer))
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_event_pump/reactions.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaEventPump
+      # The reactions the pump has made, kept as the ledger's `EventReaction` rows: one per
+      # (consumer, event, policy). The pump asks before it runs a policy, and records the reaction
+      # once the policy's command has answered, delivered or refused. The keys are read once, on
+      # first use, and kept for the run, so a pass costs one query however many events it reads.
+      class Reactions
+        # @param runtime [Hecks::Runtime::Dispatcher] the booted ledger the rows live in
+        def initialize(runtime)
+          @runtime = runtime
+          @known = nil
+        end
+
+        # @param consumer [String] the domain whose policy would run
+        # @param event_id [String] the id of the event the policy would react to
+        # @param policy [String] the policy's name
+        # @return [Boolean] whether the ledger already holds this reaction
+        def recorded?(consumer, event_id, policy)
+          known.include?(key(consumer, event_id, policy))
+        end
+
+        # @param consumer [String] the domain whose policy answered
+        # @param event_id [String] the id of the event it answered
+        # @param policy [String] the policy's name
+        # @return [void]
+        def record(consumer, event_id, policy)
+          row = key(consumer, event_id, policy)
+          @runtime.dispatch_flat("QualityControl::EventReaction.Record", key: row, consumer: consumer,
+                                                                         event_id: event_id, policy: policy)
+          known << row
+        end
+
+        private
+
+        def known
+          @known ||= @runtime.query("QualityControl::EventReaction.All").to_set { |row| row[:key][:value] }
+        end
+
+        def key(consumer, event_id, policy) = "#{consumer}/#{event_id}/#{policy}"
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_event_pump/reader.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+require "hecks/hecks/adapters/in_process_boot"
+
+module Hecks
+  module QualityControlCli
+    class QaEventPump
+      # Reads a domain's event log past a cursor through the `Operation.Follow` query, and turns
+      # each entry back into an event a policy can react to.
+      module Reader
+        module_function
+
+        # @param dir [String] the directory of the domain whose log is read
+        # @param position [Integer] the count of entries already read
+        # @return [Hash] `cursor:` the count now read to, and `events:` the entries past `position`
+        #   (each with its payload as JSON text, as the query answers it)
+        def after(dir, position)
+          Hecks::Adapters::InProcessBoot.new.follow(domain: dir, since: position, wait: 0)
+        end
+
+        # @param entry [Hash] one entry the query answered
+        # @return [Hecks::Runtime::Event] the event, with its payload parsed back to a hash
+        def event(entry)
+          Hecks::Runtime::Outbox.event_from(entry.merge("payload" => JSON.parse(entry["payload"])))
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_event_pump.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../../../hecks"
+# The era subsystem does not load with core (ADR 0033); the QualityControl ledger binds it.
+require_relative "../../ports/persistence/plugins/era"
+require_relative "qa_event_pump/attached"
+require_relative "qa_event_pump/cursors"
+require_relative "qa_event_pump/reactions"
+require_relative "qa_event_pump/reader"
+require_relative "qa_event_pump/consumer"
+
+module Hecks
+  module QualityControlCli
+    # The command behind `hecks quality_control event_pump.pump!`: reads each attached domain's
+    # event log past its cursor and runs the policies that react to what it reads. A consumer reads
+    # the logs its hecksagon subscribes to, and each cursor is one (log, consumer) row of the
+    # ledger's `EventCursor`. The pump writes no domain's event log.
+    #
+    # A policy that has an `EventReaction` row for its event is not run again. A refused reaction is
+    # recorded and named, and the cursor moves past it. A cursor does not move for an event whose
+    # reaction could not run at all: that consumer stops, and the pump exits 1.
+    class QaEventPump
+      EXIT_OK = 0
+      EXIT_ERROR = 1
+
+      USAGE = "usage: hecks quality_control event_pump.pump!"
+
+      # Runs the pump, or prints its usage for `--help`.
+      #
+      # @param argv [Array<String>] no arguments
+      # @param root [String] the repository root the attached domains are found under
+      # @param env [Hash{String => String}] `QA_SWEEP_DOMAIN_DIR` picks the ledger's bluebook
+      #   directory
+      # @return [Integer] 0 when every consumer read its logs, 1 when one could not
+      # @raise [SystemExit] when given arguments
+      def self.call(argv, root:, env: ENV)
+        return reject(argv) unless argv.empty?
+
+        new(root: root, env: env).run
+      end
+
+      # @param argv [Array<String>] the arguments given
+      # @return [Integer] 0 for `--help`
+      # @raise [SystemExit] for any other argument
+      def self.reject(argv)
+        return puts(USAGE) && EXIT_OK if %w[-h --help].include?(argv.first)
+
+        abort "#{USAGE}\nthis command takes no arguments — one pump is always the same pump"
+      end
+
+      # @param root [String] the repository root
+      # @param env [Hash{String => String}] the environment the ledger's directory is read from
+      # @param attached [Attached, nil] the attached domains; built from `root` and `env` when
+      #   absent
+      def initialize(root:, env: ENV, attached: nil)
+        @attached = attached || Attached.new(root: root, env: env)
+      end
+
+      # Runs every consumer once and prints what each reaction did.
+      #
+      # @return [Integer] 0 or 1, as `call` answers
+      def run
+        ledger = @attached.runtime("QualityControl")
+        cursors = Cursors.new(ledger)
+        reactions = Reactions.new(ledger)
+        consumers = @attached.names.map do |name|
+          Consumer.new(name, attached: @attached, cursors: cursors, reactions: reactions)
+        end
+        lines = consumers.flat_map(&:lines)
+        lines.each { |line| puts line }
+        puts "event pump: #{lines.size} line(s) reported"
+        consumers.any?(&:failed?) ? EXIT_ERROR : EXIT_OK
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_fix_main_bug/publishing.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaFixMainBug
+      # What happens after a fix is committed: the ledger records the investigation and the fix, the branch
+      # lands on local main, the ledger records the verification, and main is pushed through the push train.
+      # The push runs only after the quick gate is green on main's head, and origin's main is fetched right
+      # before it.
+      module Publishing
+        private
+
+        # Records where the bug lives and why, before any fix is attempted. Only a logged bug is
+        # investigated; a bug already investigated keeps its first note.
+        def investigate(row)
+          return unless row[:status] == "logged"
+
+          files = files_of(row)
+          ::QualityControl::Bug.find(row[:reference][:value]).investigate!(
+            site:  { value: files.empty? ? "the quick gate's output" : files.join(", ") },
+            cause: { value: "the quick gate's #{check_id(row)} check is red on main" }
+          )
+        end
+
+        def stuck(row, reason)
+          Outcome.new(EXIT_STUCK,
+                      "stays a bug: #{reason} (#{row[:reference][:value]}); left investigating for the owner")
+        end
+
+        def land_and_push(row, branch, sha)
+          reference = row[:reference][:value]
+          bug = ::QualityControl::Bug.find(reference)
+          bug.fix!(reference: { value: reference }, commit: { value: sha })
+          output, landed = @shell.land(@root, branch)
+          return Outcome.new(EXIT_STUCK, "stopped: landing #{branch} was refused: #{output.strip}") unless landed
+
+          delete_branch(branch)
+          bug.verify!(evidence: { value: "quick gate green on #{sha[0, 7]} and landed on local main from #{branch}" })
+          push_main(reference)
+        end
+
+        def delete_branch(branch)
+          QaMainGate::Worktree.try(@root, "branch", "-d", branch)
+        end
+
+        # @return [Array<QaMainGate::GateRun::Result>] the checks that are red on a commit of main
+        def red_at(head)
+          QaMainGate::Worktree.with(root: @root, ref: head) { |dir| @gate.run(dir) }.reject(&:passed)
+        end
+
+        def push_main(reference)
+          head = QaMainGate::Worktree.git!(@root, "rev-parse", "main")
+          reds = red_at(head)
+          return unpushed("main at #{head[0, 7]} is red: #{reds.map(&:id).join(", ")}") if reds.any?
+
+          behind = behind_origin
+          return unpushed(behind) if behind
+
+          output, pushed = @shell.push(@root)
+          return Outcome.new(EXIT_OK, "landed and pushed #{reference} (main at #{head[0, 7]})") if pushed
+
+          unpushed("the push train refused main: #{output.strip}")
+        end
+
+        # Fetches origin's main right before the push. @return [String, nil] why main cannot be pushed as it is
+        def behind_origin
+          QaMainGate::Worktree.git!(@root, "fetch", "origin", "main")
+          return nil if QaMainGate::Worktree.git?(@root, "merge-base", "--is-ancestor", "origin/main", "main")
+
+          "origin/main has commits local main does not have; pull main first (nothing was pushed)"
+        end
+
+        def unpushed(reason)
+          Outcome.new(EXIT_STUCK, "landed, not pushed: #{reason}")
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_fix_main_bug.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative "../../../hecks"
+# The era subsystem does not load with core (ADR 0033); the QualityControl ledger binds it.
+require_relative "../../ports/persistence/plugins/era"
+require_relative "qa_main_gate/gate_run"
+require_relative "qa_main_gate/worktree"
+require_relative "qa_main_gate/shell"
+require_relative "qa_main_gate/logging"
+require_relative "qa_fix_main_bug/publishing"
+
+module Hecks
+  module QualityControlCli
+    # The command behind `hecks quality_control bug.fix_and_land --bug BUG#n`: takes one self-contained red-main
+    # bug through a fix on a fresh branch off main, the quick gate on that exact commit, a landing on local main,
+    # and a push through the push train. A bug triaged bigger, or one whose fixer changes nothing or leaves a
+    # check red, stops before anything lands and stays open for the owner. Nothing is landed unless the gate is
+    # green on the commit, and nothing is pushed unless the gate is green on main's head.
+    #
+    # Exit 0 when the fix is landed (pushed, or the push's refusal is printed), 1 when refused before any fix,
+    # 2 when the fix stays red.
+    class QaFixMainBug
+      include Publishing
+
+      EXIT_OK = 0
+      EXIT_REFUSED = 1
+      EXIT_STUCK = 2
+
+      # The file a `rubocop` offense line starts with, as `file.rb:12:3: C: ...` prints it.
+      RUBOCOP_OFFENSE = /^(\S+\.rb):\d+:\d+:/
+
+      # The trailer every commit the practice writes carries.
+      TRAILER = "Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>"
+
+      USAGE = "usage: hecks quality_control bug.fix_and_land --bug BUG#n"
+
+      # The outcome of one bug's attempt.
+      #
+      # @!attribute [r] code
+      #   @return [Integer] the exit status this attempt earns
+      # @!attribute [r] message
+      #   @return [String] one line for the report
+      Outcome = Struct.new(:code, :message)
+
+      # A fix attempt that did not produce a green commit.
+      Stuck = Struct.new(:reason)
+
+      # Runs the command.
+      #
+      # @param argv [Array<String>] `--bug BUG#n`
+      # @param root [String] the repository root
+      # @param env [Hash{String => String}] `QA_SWEEP_DOMAIN_DIR` picks another ledger
+      # @param gate [#run] the quick gate's runner; a spec injects one
+      # @param shell [Module] the fixer, landing and push commands; a spec injects one
+      # @return [Integer] the exit status
+      def self.call(argv, root:, env: ENV, gate: QaMainGate::GateRun, shell: QaMainGate::Shell)
+        reference = parse(argv)
+        return EXIT_REFUSED unless reference
+
+        runtime = Hecks.boot(env.fetch("QA_SWEEP_DOMAIN_DIR", File.join(root, "qa/bluebook")))
+        outcome = new(runtime: runtime, root: root, gate: gate, shell: shell).fix(reference)
+        puts outcome.message
+        outcome.code
+      end
+
+      # @return [String, nil] the reference, or nil after printing the usage for bad arguments
+      def self.parse(argv)
+        index = argv.index("--bug")
+        return argv[index + 1] if index && argv[index + 1]
+
+        warn USAGE
+        nil
+      end
+
+      # @param runtime [Object] the booted QualityControl ledger
+      # @param root [String] the repository root
+      # @param gate [#run] the quick gate's runner
+      # @param shell [Module] the fixer, landing and push commands
+      def initialize(runtime:, root:, gate:, shell:)
+        @runtime = runtime
+        @root = root
+        @gate = gate
+        @shell = shell
+      end
+
+      # @param reference [String] the bug's reference, such as `BUG#12`
+      # @return [Outcome] what happened, once, in one line
+      def fix(reference)
+        row = bug_row(reference)
+        refusal = refusal_for(reference, row)
+        return Outcome.new(EXIT_REFUSED, "refused: #{refusal}") if refusal
+
+        attempt(row)
+      rescue QaMainGate::Worktree::Failed => e
+        Outcome.new(EXIT_STUCK, "stopped: #{e.message}")
+      end
+
+      private
+
+      def attempt(row)
+        branch = branch_for(row[:reference][:value])
+        return Outcome.new(EXIT_REFUSED, "refused: branch #{branch} already exists") if branch_exists?(branch)
+
+        investigate(row)
+        outcome = QaMainGate::Worktree.with(root: @root, ref: "main", branch: branch) { |dir| fix_in(dir, row) }
+        return stuck(row, outcome.reason) if outcome.is_a?(Stuck)
+
+        land_and_push(row, branch, outcome)
+      end
+
+      def bug_row(reference)
+        @runtime.query("QualityControl::Bug.All").find { |row| row[:reference][:value] == reference }
+      end
+
+      # @return [String, nil] why the bug is not fixed by this command, nil when it may be
+      def refusal_for(reference, row)
+        return "no such bug #{reference}" unless row
+        return "#{reference} is triaged #{row[:disposition][:value]}; a bigger bug is left for the owner" unless
+          row[:disposition][:value] == "self_contained"
+        return "#{reference} is #{row[:status]}; nothing to fix" unless %w[logged investigating].include?(row[:status])
+
+        "no mechanical fixer for #{check_id(row)}" unless QaMainGate::Logging::SELF_CONTAINED.include?(check_id(row))
+      end
+
+      # @return [String] the gate check the bug is about, such as `rubocop`
+      def check_id(row)
+        (row[:name] && row[:name][:value]).to_s.delete_prefix("main-red-").tr("-", "_")
+      end
+
+      # @return [Array<String>] the files the failing check named, from its own output
+      def files_of(row)
+        row[:demonstration][:value].scan(RUBOCOP_OFFENSE).flatten.uniq
+      end
+
+      def branch_for(reference)
+        "qa/red-main-#{reference.downcase.tr("#", "-")}"
+      end
+
+      def branch_exists?(branch)
+        QaMainGate::Worktree.git?(@root, "rev-parse", "--verify", "--quiet", "refs/heads/#{branch}")
+      end
+
+      # The fixer runs, then the gate on the exact commit it makes. Returns the commit, or what kept it red.
+      def fix_in(dir, row)
+        @shell.rubocop(dir, files_of(row))
+        return Stuck.new("the fixer changed nothing") unless changed?(dir)
+
+        sha = commit(dir, row)
+        reds = @gate.run(dir).reject(&:passed)
+        return sha if reds.empty?
+
+        Stuck.new("the quick gate is still red on the fix: #{reds.map(&:id).join(", ")}")
+      end
+
+      def changed?(dir)
+        !QaMainGate::Worktree.git!(dir, "status", "--porcelain").empty?
+      end
+
+      def commit(dir, row)
+        QaMainGate::Worktree.git!(dir, "add", "-A")
+        title = "Fix the quick gate on main: #{check_id(row)} (#{row[:reference][:value]})"
+        QaMainGate::Worktree.git!(dir, "commit", "-m", title, "-m", TRAILER)
+        QaMainGate::Worktree.git!(dir, "rev-parse", "HEAD")
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_generated_domains/evaluation.rb

@@ -86,7 +86,7 @@ module Hecks
 
         def sync_scratch!
           FileUtils.mkdir_p(@scratch)
-          sources = %w[Cargo.toml Cargo.lock src].map { |entry| File.join(@root, "rust", entry) }
+          sources = %w[Cargo.toml Cargo.lock src expr].map { |entry| File.join(@root, "rust", entry) }
           system("rsync", "-a", "--delete", "--exclude", "target", *sources, "#{@scratch}/") or
             abort "rsync into #{@scratch} failed"
         end