hecks 3.5.0 → 3.6.0

data/lib/hecks/quality_control/cli/qa_mine_combinations/arguments.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaMineCombinations
+      # The command line of `target.mine_combinations`: flags into an options hash.
+      module Arguments
+        # Each flag that takes a value: the option it sets and how the value is read.
+        VALUE_FLAGS = {
+          "--candidates" => [:candidates, ->(v) { Integer(v) }], "--seeds" => [:seeds, ->(v) { Integer(v) }],
+          "--steps" => [:steps, ->(v) { Integer(v) }], "--adversarial" => [:adversarial, ->(v) { Float(v) }],
+          "--repair-rounds" => [:repair_rounds, ->(v) { Integer(v) }], "--agent" => [:agent, :itself.to_proc],
+          "--from" => [:from, ->(v) { File.expand_path(v) }]
+        }.freeze
+
+        private
+
+        # @param argv [Array<String>] consumed as it is read
+        # @return [Hash, Symbol] the options, or `:help` after the usage line was printed
+        # @raise [SystemExit] on an unknown flag
+        def parse(argv)
+          options = default_options
+          until argv.empty?
+            arg = argv.shift
+            if %w[-h --help].include?(arg)
+              puts USAGE
+              return :help
+            end
+            parse_flag(options, arg, argv)
+          end
+          options
+        end
+
+        def default_options
+          { candidates: 3, rust: false, seeds: 5, steps: 25, adversarial: 0.3, repair_rounds: 1,
+            agent: nil, from: nil, brief: false, confine: false, against: [] }
+        end
+
+        def parse_flag(options, arg, argv)
+          case arg
+          when *VALUE_FLAGS.keys
+            key, reader = VALUE_FLAGS.fetch(arg)
+            options[key] = reader.call(argv.shift)
+          when "--rust" then options[:rust] = true
+          when "--brief" then options[:brief] = true
+          when "--confine" then options[:confine] = true
+          when "--against" then options[:against] << File.expand_path(argv.shift)
+          else abort "#{USAGE}\nunexpected argument: #{arg.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_mine_combinations/booting.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Hecks
+  module QualityControlCli
+    class QaMineCombinations
+      # The boot check of `target.mine_combinations`: which candidates boot, the repair rounds the
+      # agent gets for those that do not, and the per-candidate report.
+      module Booting
+        private
+
+        # @return [Array(Hash, Array<String>)] the slug-to-error map of candidates that never
+        #   booted, and the slugs a repair round fixed
+        def boot_and_repair(candidates)
+          boot_root = File.join(@run_dir, "boot")
+          failures = failing(candidates, boot_root)
+          repaired = []
+          @options[:repair_rounds].times do |round|
+            break if failures.empty? || @options[:from]
+
+            still = repair_round(round, failures, boot_root)
+            repaired.concat(slugs(failures) - slugs(still))
+            failures = still
+          end
+          [failures.to_h { |candidate, error| [candidate[:slug], error] }, repaired]
+        end
+
+        def slugs(failures)
+          failures.map { |candidate, _| candidate[:slug] }
+        end
+
+        # @return [Array<Array>] the `[candidate, error]` pairs of candidates that do not boot
+        def failing(candidates, boot_root)
+          candidates.filter_map { |candidate| (error = boot_error(candidate, boot_root)) && [candidate, error] }
+        end
+
+        def repair_round(round, failures, boot_root)
+          puts "repair round #{round + 1}: #{failures.size} candidate(s) did not boot — back to the agent…"
+          failure = ask_agent(Miner.repair_prompt(failures, out_dir: @out_dir))
+          abort "combination miner: #{failure}" if failure
+
+          failing(failures.map(&:first), boot_root)
+        end
+
+        def boot_error(candidate, boot_root)
+          dir = write_boot_domain(candidate, boot_root)
+          output, = Open3.capture2e(*Child.argv(@root, "qa_generated_domains", "--check", dir, "--seeds", "0"),
+                                    chdir: @root)
+          line = output.lines.reverse.find { |candidate_line| candidate_line.start_with?(RESULT_MARKER) }
+          return "boot check produced no result: #{output.lines.last(5).join.strip}" unless line
+
+          result = JSON.parse(line.delete_prefix(RESULT_MARKER))
+          result["status"] == "invalid" ? result["error"] : nil
+        end
+
+        def write_boot_domain(candidate, boot_root)
+          Hecks::Fuzzing::DomainGenerator.write(
+            { "source" => File.read(candidate[:bluebook]), "aggregates" => [], "policies" => [] },
+            File.join(boot_root, candidate[:slug])
+          )
+        end
+
+        def report(candidates, invalid, repaired)
+          puts
+          candidates.each do |candidate|
+            if invalid.key?(candidate[:slug])
+              puts "  #{candidate[:slug]}: INVALID — #{invalid[candidate[:slug]]}"
+            else
+              print_booted(candidate, repaired)
+            end
+          end
+        end
+
+        def print_booted(candidate, repaired)
+          pairs = new_pairs_for(candidate)
+          puts "  #{candidate[:slug]}: boots#{" (repaired)" if repaired.include?(candidate[:slug])}; " \
+               "new pair(s): #{pairs.empty? ? "none" : pairs.join(", ")}"
+          first = first_hypothesis_line(candidate)
+          puts "    #{first}" if first
+        end
+
+        def first_hypothesis_line(candidate)
+          candidate[:hypothesis].to_s.lines.map(&:strip).find { |line| !line.empty? && !line.start_with?("#") }
+        end
+
+        def new_pairs_for(candidate)
+          Miner.new_pairs(candidate[:dir], @brief["covered"])
+        rescue StandardError, ScriptError => e
+          ["(census failed: #{e.class})"]
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "json"
-require "open3"
 require_relative "../../../hecks"
 require_relative "../../fuzzing/combination_miner"
 require_relative "../../fuzzing/domain_generator"
@@ -10,6 +8,8 @@ require_relative "../adapters/agent"
 require_relative "child"
 require_relative "../../cache_dir"
 require_relative "../../hecks/adapters/codebase/tree"
+require_relative "qa_mine_combinations/arguments"
+require_relative "qa_mine_combinations/booting"
 
 module Hecks
   module QualityControlCli
@@ -25,6 +25,9 @@ module Hecks
     # this command's report. Exit 0: all clean. 2: a finding (see
     # `.claude/skills/hecks_qa/SKILL.md`). 1: an operational error.
     class QaMineCombinations
+      include Arguments
+      include Booting
+
       EXIT_OK = 0
       EXIT_ERROR = 1
       RESULT_MARKER = "QA_GENERATED_RESULT "
@@ -66,14 +69,7 @@ module Hecks
         @options = parse(argv.dup)
         return EXIT_OK if @options == :help
 
-        @run_dir = File.join(runs_root, "run-#{Time.now.strftime('%Y%m%d-%H%M%S')}-#{Process.pid}")
-        @out_dir = @options[:from] || File.join(@run_dir, "candidates")
-        @agent_log = File.join(@run_dir, "agent.log")
-        @agent = Hecks::Adapters::Agent.new
-        @profile = confinement_profile if @options[:confine]
-        @command = @agent.command_for(@options[:agent], @profile)
-        corpus = @options[:against].empty? ? Miner.corpus_paths(@root) : @options[:against]
-        @brief = Miner.brief(corpus, root: @root, bug_titles: Miner.recent_bug_titles(@root))
+        prepare_run
         prompt = Miner.prompt(@root, @brief, count: @options[:candidates], out_dir: @out_dir)
         if @options[:brief]
           puts prompt
@@ -83,41 +79,21 @@ module Hecks
         mine(prompt)
       end
 
-      # Each flag that takes a value: the option it sets and how the value is read.
-      VALUE_FLAGS = {
-        "--candidates" => [:candidates, ->(v) { Integer(v) }], "--seeds" => [:seeds, ->(v) { Integer(v) }],
-        "--steps" => [:steps, ->(v) { Integer(v) }], "--adversarial" => [:adversarial, ->(v) { Float(v) }],
-        "--repair-rounds" => [:repair_rounds, ->(v) { Integer(v) }], "--agent" => [:agent, :itself.to_proc],
-        "--from" => [:from, ->(v) { File.expand_path(v) }]
-      }.freeze
-
       private
 
-      def parse(argv)
-        options = { candidates: 3, rust: false, seeds: 5, steps: 25, adversarial: 0.3, repair_rounds: 1,
-                    agent: nil, from: nil, brief: false, confine: false, against: [] }
-        until argv.empty?
-          arg = argv.shift
-          if %w[-h --help].include?(arg)
-            puts USAGE
-            return :help
-          end
-          parse_flag(options, arg, argv)
-        end
-        options
+      def prepare_run
+        @run_dir = File.join(runs_root, "run-#{Time.now.strftime("%Y%m%d-%H%M%S")}-#{Process.pid}")
+        @out_dir = @options[:from] || File.join(@run_dir, "candidates")
+        @agent_log = File.join(@run_dir, "agent.log")
+        @agent = Hecks::Adapters::Agent.new
+        @profile = confinement_profile if @options[:confine]
+        @command = @agent.command_for(@options[:agent], @profile)
+        @brief = mined_brief
       end
 
-      def parse_flag(options, arg, argv)
-        case arg
-        when *VALUE_FLAGS.keys
-          key, reader = VALUE_FLAGS.fetch(arg)
-          options[key] = reader.call(argv.shift)
-        when "--rust" then options[:rust] = true
-        when "--brief" then options[:brief] = true
-        when "--confine" then options[:confine] = true
-        when "--against" then options[:against] << File.expand_path(argv.shift)
-        else abort "#{USAGE}\nunexpected argument: #{arg.inspect}"
-        end
+      def mined_brief
+        corpus = @options[:against].empty? ? Miner.corpus_paths(@root) : @options[:against]
+        Miner.brief(corpus, root: @root, bug_titles: Miner.recent_bug_titles(@root))
       end
 
       def relative(path) = path.delete_prefix("#{@root}/")
@@ -144,91 +120,51 @@ module Hecks
                                           timeout: CONFINED_TIMEOUT, budget: CONFINED_BUDGET)
       end
 
-      def boot_error(candidate, boot_root)
-        dir = Hecks::Fuzzing::DomainGenerator.write(
-          { "source" => File.read(candidate[:bluebook]), "aggregates" => [], "policies" => [] },
-          File.join(boot_root, candidate[:slug])
-        )
-        output, = Open3.capture2e(*Child.argv(@root, "qa_generated_domains", "--check", dir, "--seeds", "0"),
-                                  chdir: @root)
-        line = output.lines.reverse.find { |candidate_line| candidate_line.start_with?(RESULT_MARKER) }
-        return "boot check produced no result: #{output.lines.last(5).join.strip}" unless line
-
-        result = JSON.parse(line.delete_prefix(RESULT_MARKER))
-        result["status"] == "invalid" ? result["error"] : nil
-      end
-
       def mine(prompt)
-        FileUtils.mkdir_p(@out_dir)
-        FileUtils.mkdir_p(@run_dir)
-        puts "combination miner: #{@brief['corpus'].size} corpus domain(s), " \
-             "#{@brief['unmet_pairs'].size} unmet pair(s) — #{relative(@run_dir)}"
-        unless @options[:from]
-          puts "asking the agent for #{@options[:candidates]} candidate(s) (#{@command.first}; " \
-               "log #{relative(@agent_log)})…"
-          failure = ask_agent(prompt)
-          abort "combination miner: #{failure}" if failure
-        end
-
+        [@out_dir, @run_dir].each { |dir| FileUtils.mkdir_p(dir) }
+        announce_corpus
+        ask_for_candidates(prompt) unless @options[:from]
         candidates = Miner.candidates(@out_dir)
         abort "combination miner: the agent wrote no candidates under #{relative(@out_dir)}" if candidates.empty?
 
-        invalid, repaired = boot_and_repair(candidates)
-        report(candidates, invalid, repaired)
-        valid = candidates.reject { |candidate| invalid.key?(candidate[:slug]) }
-        abort "combination miner: no candidate booted — nothing to check" if valid.empty?
-
+        valid = booted(candidates)
         puts
         check(valid)
       end
 
-      # @return [Array(Hash, Array<String>)] the slug-to-error map of candidates that never booted,
-      #   and the slugs a repair round fixed
-      def boot_and_repair(candidates)
-        boot_root = File.join(@run_dir, "boot")
-        failures = candidates.filter_map { |candidate| (error = boot_error(candidate, boot_root)) && [candidate, error] }
-        repaired = []
-        @options[:repair_rounds].times do |round|
-          break if failures.empty? || @options[:from]
-
-          puts "repair round #{round + 1}: #{failures.size} candidate(s) did not boot — back to the agent…"
-          failure = ask_agent(Miner.repair_prompt(failures, out_dir: @out_dir))
-          abort "combination miner: #{failure}" if failure
-
-          still = failures.filter_map { |candidate, _| (error = boot_error(candidate, boot_root)) && [candidate, error] }
-          repaired.concat(failures.map { |candidate, _| candidate[:slug] } - still.map { |candidate, _| candidate[:slug] })
-          failures = still
-        end
-        [failures.to_h { |candidate, error| [candidate[:slug], error] }, repaired]
+      def announce_corpus
+        puts "combination miner: #{@brief["corpus"].size} corpus domain(s), " \
+             "#{@brief["unmet_pairs"].size} unmet pair(s) — #{relative(@run_dir)}"
       end
 
-      def report(candidates, invalid, repaired)
-        puts
-        candidates.each do |candidate|
-          if invalid.key?(candidate[:slug])
-            puts "  #{candidate[:slug]}: INVALID — #{invalid[candidate[:slug]]}"
-            next
-          end
-
-          pairs = begin
-            Miner.new_pairs(candidate[:dir], @brief["covered"])
-          rescue StandardError, ScriptError => e
-            ["(census failed: #{e.class})"]
-          end
-          puts "  #{candidate[:slug]}: boots#{' (repaired)' if repaired.include?(candidate[:slug])}; " \
-               "new pair(s): #{pairs.empty? ? 'none' : pairs.join(', ')}"
-          first = candidate[:hypothesis].to_s.lines.map(&:strip).find { |line| !line.empty? && !line.start_with?("#") }
-          puts "    #{first}" if first
-        end
+      def ask_for_candidates(prompt)
+        puts "asking the agent for #{@options[:candidates]} candidate(s) (#{@command.first}; " \
+             "log #{relative(@agent_log)})…"
+        failure = ask_agent(prompt)
+        abort "combination miner: #{failure}" if failure
+      end
+
+      # The candidates that boot, once the boot report is printed.
+      def booted(candidates)
+        invalid, repaired = boot_and_repair(candidates)
+        report(candidates, invalid, repaired)
+        valid = candidates.reject { |candidate| invalid.key?(candidate[:slug]) }
+        abort "combination miner: no candidate booted — nothing to check" if valid.empty?
+
+        valid
       end
 
       def check(valid)
+        _, status = Process.wait2(Process.spawn(*Child.argv(@root, "qa_generated_domains", *check_args(valid)),
+                                                chdir: @root))
+        status.exitstatus || EXIT_ERROR
+      end
+
+      def check_args(valid)
         args = ["--start", (Time.now.to_i % 1_000_000).to_s, "--seeds", @options[:seeds].to_s,
                 "--steps", @options[:steps].to_s, "--adversarial", @options[:adversarial].to_s]
         args << "--rust" if @options[:rust]
         args.concat(valid.flat_map { |candidate| ["--source", candidate[:bluebook]] })
-        _, status = Process.wait2(Process.spawn(*Child.argv(@root, "qa_generated_domains", *args), chdir: @root))
-        status.exitstatus || EXIT_ERROR
       end
     end
   end

data/lib/hecks/quality_control/cli/qa_open_pr/arguments.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaOpenPr
+      # The command line of `patch.open` and `improvement.open`: flags into an options hash. A wrong
+      # command line aborts with the usage line.
+      module Arguments
+        private
+
+        # @param argv [Array<String>] consumed as it is read
+        # @return [Hash, Symbol] the options, or `:help` after the usage line was printed
+        # @raise [SystemExit] on a flag without a value, an unknown flag or an inconsistent set
+        def parse(argv)
+          options = {}
+          until argv.empty?
+            arg = argv.shift
+            if %w[-h --help].include?(arg)
+              puts USAGE
+              return :help
+            end
+            read_flag(options, arg, argv)
+          end
+          validate(options)
+        end
+
+        def read_flag(options, arg, argv)
+          case arg
+          when "--improvement" then options[:improvement] = true
+          when "--bug", "--angle", "--title", "--body" then options[arg.delete_prefix("--").to_sym] = flag_value(arg, argv)
+          else abort "#{USAGE}\nunexpected argument: #{arg.inspect}"
+          end
+        end
+
+        def flag_value(flag, argv)
+          value = argv.shift
+          abort "#{USAGE}\n#{flag} needs a value" if value.nil? || value.empty?
+          value
+        end
+
+        def validate(options)
+          abort "#{USAGE}\n--title is required" unless options[:title]
+          validate_citation(options)
+          options
+        end
+
+        def validate_citation(options)
+          abort "#{USAGE}\ngive --bug BUG#n OR --improvement, not both" if options[:bug] && options[:improvement]
+          abort "#{USAGE}\ngive --bug BUG#n or --improvement" unless options.key?(:bug) || options.key?(:improvement)
+          abort "#{USAGE}\n--angle only means something with --improvement" if options[:angle] && !options[:improvement]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_open_pr/recording.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaOpenPr
+      # What `patch.open` and `improvement.open` write to the ledger once the PR exists: the Patch
+      # or Improvement record, the day's quota slot and the optional auto-merge.
+      module Recording
+        private
+
+        # Counts the PR just recorded against the day, opening the day's record on its first.
+        def take_daily_slot
+          row = todays_quota
+          quota = row ? ::QualityControl::DailyQuota.find(row[:today][:value]) : ::QualityControl::DailyQuota.open!
+          quota.take!(cap: { value: dial(:PR_CAP_PER_DAY, 0) })
+        end
+
+        def record(view)
+          number = view[:number]
+          sha = view[:headRefOid].to_s
+          now = Time.now.to_i
+          if @bug
+            record_patch(view, number, sha, now)
+          else
+            record_improvement(view, number, sha, now)
+          end
+        end
+
+        def record_patch(view, number, sha, now)
+          return puts("Patch ##{number} already recorded — not re-recording") if patch_recorded?(number)
+
+          ::QualityControl::Patch.open!(
+            bug: @bug.id, number: { value: number }, url: { value: view[:url] },
+            branch: { value: view[:headRefName] }, commit: { value: sha }, title: { value: view[:title] },
+            now: { value: now }
+          )
+          take_daily_slot
+          puts "recorded Patch ##{number} for #{@bug.id} at #{sha[0, 7]}"
+        end
+
+        def patch_recorded?(number)
+          query("Patch.All").map { |row| row[:number][:value] }.include?(number)
+        end
+
+        def record_improvement(view, number, sha, now)
+          existing = ::QualityControl::Improvement.find(number)
+          if existing && existing.status != "opened"
+            puts "Improvement ##{number} already recorded (#{existing.status}) — not re-recording"
+            return
+          end
+
+          # A run that stopped between `open!` and `land!` leaves the record `opened`: finish it.
+          open_improvement(view, number, now) unless existing
+          ::QualityControl::Improvement.find(number).land!(number: { value: number }, commit: { value: sha })
+          puts "recorded Improvement ##{number}#{" for #{@angle.id}" if @angle}, landed at #{sha[0, 7]}"
+        end
+
+        def open_improvement(view, number, now)
+          ::QualityControl::Improvement.open!(
+            **(@angle ? { angle: @angle.id } : {}),
+            number: { value: number }, url: { value: view[:url] },
+            branch: { value: view[:headRefName] }, title: { value: view[:title] },
+            now: { value: now }
+          )
+          take_daily_slot
+        end
+
+        def merge_when_green(number)
+          begin
+            @git_pr.merge_when_green(number)
+          rescue Hecks::Adapters::GitPr::CommandFailed => e
+            abort "recorded, but #{e.message}"
+          end
+          puts "auto-merge queued for ##{number} (QualityControlDials::AUTO_MERGE)"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_open_pr/rules.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaOpenPr
+      # The rules `patch.open` and `improvement.open` check before anything is opened: the ledger's
+      # own `given`s, asked as a dry run, then the day's cap and the bug's commit ancestry.
+      module Rules
+        private
+
+        def find_citations
+          @bug = @angle = nil
+          if @options[:bug]
+            @bug = ::QualityControl::Bug.find(@options[:bug])
+            abort "refused: no such bug #{@options[:bug].inspect}" unless @bug
+          end
+          return unless @options[:angle]
+
+          @angle = ::QualityControl::Angle.find(@options[:angle])
+          abort "refused: no such angle #{@options[:angle].inspect}" unless @angle
+        end
+
+        # What a refused `given` says to do next, by the rule's own wording; nothing for a rule it
+        # does not know.
+        def hint_for(rule)
+          case rule
+          when "the bug is fixed" then bug_hint
+          when "the angle is under investigation" then angle_hint
+          when "the branch is one this practice recognises as its own" then branch_hint
+          when "the day's cap is not spent" then cap_hint
+          else ""
+          end
+        end
+
+        def bug_hint
+          " (#{@bug.id} is #{@bug.status.inspect} — dispatch investigate and fix first " \
+            "(hecks run qa/bluebook fix id=#{@bug.id} reference.value=#{@bug.id} commit.value=<sha>))"
+        end
+
+        def angle_hint
+          " (#{@angle.id} is #{@angle.status.inspect} — dispatch angle.investigate first, so the lead " \
+            "reads as picked up before something is built from it)"
+        end
+
+        def branch_hint
+          " (the branch is #{@branch.inspect}; a PR this practice opens is on a branch it can recognise " \
+            "as its own)"
+        end
+
+        def cap_hint
+          " (QualityControlDials::PR_CAP_PER_DAY is #{dial(:PR_CAP_PER_DAY, 0)} — leave this as an open " \
+            "Bug/Angle and open it tomorrow, or raise the dial in qa/settings.yml)"
+        end
+
+        # Asks the ledger whether `verb` would take these facts, without recording anything. The
+        # number is one no record holds yet, so the dry run reaches the `given`s rather than
+        # `AlreadyExists`.
+        def refuse_unless_ledger_takes(verb, **facts)
+          @runtime.dry_run?(verb, **facts)
+        rescue Hecks::Runtime::GivenNotMet => e
+          hint = hint_for(e.message.split(" — ", 2).last)
+          abort "refused: #{e.message}#{hint} — a dry run of #{verb}, so nothing was opened or recorded"
+        end
+
+        def next_number(aggregate)
+          query("#{aggregate}.All").map { |row| row[:number][:value] }.max.to_i + 1
+        end
+
+        def check_rules
+          recorded = recorded_facts
+          @bug ? check_patch_rule(recorded) : check_improvement_rule(recorded)
+          check_daily_cap
+          check_ancestry
+        end
+
+        def recorded_facts
+          { url: { value: "https://github.com/pull/0" }, title: { value: @options[:title] },
+            branch: { value: @branch }, now: { value: Time.now.to_i } }
+        end
+
+        def check_patch_rule(recorded)
+          commit = @bug.commit.to_h[:value].to_s
+          refuse_unless_ledger_takes("QualityControl::Patch.Open",
+                                     bug: @bug.id, number: { value: next_number("Patch") },
+                                     commit: { value: commit.match?(SHA_PATTERN) ? commit : PLACEHOLDER_COMMIT },
+                                     **recorded)
+        end
+
+        def check_improvement_rule(recorded)
+          refuse_unless_ledger_takes("QualityControl::Improvement.Open",
+                                     **(@angle ? { angle: @angle.id } : {}),
+                                     number: { value: next_number("Improvement") }, **recorded)
+        end
+
+        # The record of the UTC day the clock reads: `DailyQuota.Today` fills the day from the
+        # clock.
+        def todays_quota = query("DailyQuota.Today").first
+
+        # A day with no record has spent nothing, so only an opened day can refuse.
+        def check_daily_cap
+          cap = dial(:PR_CAP_PER_DAY, 0)
+          quota = todays_quota
+          return unless cap.positive? && quota
+
+          refuse_unless_ledger_takes("QualityControl::DailyQuota.Take", today: quota[:today], cap: { value: cap })
+        end
+
+        def check_ancestry
+          return unless @bug
+
+          commit = @bug.commit.to_h[:value].to_s
+          abort "refused: #{@bug.id} carries no commit" unless commit.match?(SHA_PATTERN)
+
+          refusing do
+            @git_pr.assert_ancestor!(commit: commit, owner: @bug.id)
+            @git_pr.assert_pushed!(branch: @branch, commit: commit, owner: @bug.id)
+          end
+        end
+      end
+    end
+  end
+end