hecks 3.4.2 → 3.6.0

data/lib/hecks/quality_control/cli/qa_sweep/conclusion.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaSweep
+      # How a single-target sweep ends: a report and exit 2 on a finding, or a concluded sweep and a
+      # released target when every seed held.
+      module Conclusion
+        private
+
+        # Reads the sticky per-check `ever_surprised` bit rather than a loop's local, so a surprise
+        # resolved before concluding never reads as clean. `&.` because rows logged before that
+        # attribute existed lack the key; missing means no sticky surprise.
+        def sweep_was_clean?(sweep)
+          sweep.checks.none? { |c| c[:ever_surprised]&.[](:value) == "yes" }
+        end
+
+        # Decays the target's yield_score, adds this period's finds, and moves the streak (see
+        # `Target.Release`).
+        def release_target!(target, capabilities, current_streak, surprises:, clean:)
+          next_yield_score = Hecks::Fuzzing::RotationPriority.next_yield_score(
+            old_score: target.yield_score.value, surprises_this_period: surprises
+          )
+          target.release!(now: { value: Time.now.to_i }, yield_score: { value: next_yield_score },
+                          next_streak: { value: clean ? current_streak + 1 : 0 },
+                          capabilities: { value: capabilities.join(",") })
+        end
+
+        def report_finding(surprise)
+          print_finding(surprise)
+          EXIT_FOUND_SOMETHING
+        end
+
+        # Reached only when every seed held; re-reads the sticky `ever_surprised` bit, not the
+        # loop's local.
+        def conclude_clean_sweep
+          notes = clean_sweep_notes
+          @sweep.conclude!(notes: { value: notes })
+          trace("seed loop+conclude")
+
+          target = release_target!(@target, @capabilities, @current_streak, surprises: 0, clean: sweep_was_clean?(@sweep))
+          trace("release")
+
+          puts
+          puts "clean — #{@target_reference} concluded and released. clean_streak: #{@current_streak} -> " \
+               "#{target.clean_streak.value}. capabilities: #{target.capabilities.value.inspect}"
+          puts notes
+          EXIT_OK
+        end
+
+        def clean_sweep_notes
+          "domain=#{@target_reference} path=#{@target_path} mode=#{@mode} modes=#{@active_modes.join(",")} " \
+            "capabilities=#{@capabilities.join(",")} feature=#{@feature} seeds=#{@seeds} " \
+            "steps=#{@steps_per_sequence} adversarial=#{@adversarial} role_draw=#{@role_draw} " \
+            "dry_run=#{@dry_run} — every seed held, no divergence or property violation found."
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_sweep/depth.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaSweep
+      # How deep a single-target sweep goes: seeds and steps from the target's clean streak, the
+      # clamps on seeds, and the lines that announce the resolution.
+      module Depth
+        # Why `--seeds` is clamped for `--persistence-parity`.
+        PARITY_CLAMP_REASON = "Real PostgresEra I/O per dispatch is genuinely expensive"
+
+        # Why `--seeds` is clamped for `concurrency`.
+        CONCURRENCY_CLAMP_REASON = "Each seed forks two real racers against real PostgresEra I/O"
+
+        private
+
+        # Read once after claiming: nothing before `Target.Release` changes `clean_streak`, and it
+        # sizes this sweep and seeds `next_streak`.
+        def resolve_depth
+          @current_streak = @target.clean_streak.value
+          default_seeds, default_steps = Hecks::Fuzzing::SweepDepth.for_streak(@current_streak, tiers: @widening_tiers)
+          @seeds = @seeds_override || default_seeds
+          @steps_per_sequence = @steps_override || default_steps
+
+          # Only when depth is auto-resolved from the streak: an explicit `--seeds N` is a person's
+          # manual debugging/reproduction run, and stays the predictable `1..N`. Growing this with
+          # the streak is what keeps a matured target's sweep moving into seed integers it has
+          # never generated before (see `Hecks::Fuzzing::SweepDepth.seed_offset`).
+          @seed_offset = @seeds_override ? 0 : Hecks::Fuzzing::SweepDepth.seed_offset(@current_streak, default_seeds)
+          clamp_seeds
+        end
+
+        # Clamps down (never up) only for `--persistence-parity`: real PostgresEra I/O per dispatch
+        # is expensive even for a target on the widest tier. `concurrency` has a tighter cap: each
+        # seed pays for two disposable schemas and a real fork; it is reached via `--modes
+        # concurrency`.
+        def clamp_seeds
+          clamp_seeds_to(:PERSISTENCE_PARITY_SEED_CAP, PARITY_CLAMP_REASON) if @persistence_parity_mode
+          clamp_seeds_to(:CONCURRENCY_SEED_CAP, CONCURRENCY_CLAMP_REASON) if @active_modes.include?(:concurrency)
+        end
+
+        def clamp_seeds_to(dial_name, reason)
+          cap = ::QualityControlDials.const_get(dial_name)
+          return unless @seeds > cap
+
+          puts "note: --seeds #{@seeds} exceeds QualityControlDials::#{dial_name} (#{cap}) — clamping down. " \
+               "#{reason}; edit that dial in qa/settings.yml to run more."
+          @seeds = cap
+        end
+
+        def announce_resolution
+          puts "resolved depth: seeds=#{@seeds} steps=#{@steps_per_sequence} (clean_streak=#{@current_streak})"
+          puts "seed range: #{@seed_offset + 1}..#{@seed_offset + @seeds}" if @seeded_modes.any?
+          line = "resolved modes: #{@active_modes.join(",")} (capabilities=#{@capabilities.join(",")}"
+          line += "; deferred=#{@deferred_modes.join(",")}" unless @deferred_modes.empty?
+          puts "#{line})"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_sweep/dials.rb

@@ -17,14 +17,23 @@ module Hecks
         # Dials are read after boot because the bluebook defines them; a dial-less fixture ledger
         # runs the adversarial layer off and self-consistency on.
         def read_dials
+          read_sampling_dials
+          read_loop_dials
+          read_limit_dials
+        end
+
+        def read_sampling_dials
           @adversarial ||= dial(:ADVERSARIAL_FRACTION, 0.0).to_f
+          # Same off-without-a-dial default as the adversarial layer.
+          @role_draw ||= dial(:ROLE_DRAW_PROBABILITY, 0.0).to_f
+          @dry_run ||= dial(:DRY_RUN_FRACTION, 0.0).to_f
           # Remembered before defaulting: the alias below applies only when the flag was typed, so
           # an explicit `--modes ruby_only` stays exclusive.
           @self_consistency_explicit = !@self_consistency.nil?
           @self_consistency = dial(:SELF_CONSISTENCY_CHECKS, true) if @self_consistency.nil?
-          # Same off-without-a-dial default as the adversarial layer.
-          @role_draw ||= dial(:ROLE_DRAW_PROBABILITY, 0.0).to_f
-          @dry_run ||= dial(:DRY_RUN_FRACTION, 0.0).to_f
+        end
+
+        def read_loop_dials
           # The loop's identity: `held_by` on claims, `engineer` on sweeps, and the literal
           # `WaivedBy` refuses.
           @engineer = dial(:AUTOMATED_ENGINEER, "qa_sweep")
@@ -32,6 +41,9 @@ module Hecks
           @guided_generation = dial(:GUIDED_GENERATION, false)
           @corpus_splice_probability = dial(:CORPUS_SPLICE_PROBABILITY, 0.5)
           @favor_rare_verbs = dial(:FAVOR_RARE_VERBS, 3)
+        end
+
+        def read_limit_dials
           @max_parallel = dial(:SWEEP_MAX_PARALLEL, 4)
           @shrink_budget = dial(:SHRINK_BUDGET, 200)
           @structural_boundary = dial(:STRUCTURAL_REFUSAL_BOUNDARY, [])
@@ -47,22 +59,23 @@ module Hecks
         # stays exact.
         def resolve_enabled_modes
           @enabled_modes = @explicit_modes || dial_modes
-          if @self_consistency_explicit || @explicit_modes.nil?
-            @enabled_modes = if @self_consistency
-                               @enabled_modes | [:self_consistency]
-                             else
-                               @enabled_modes - [:self_consistency]
-                             end
-          end
+          apply_self_consistency if @self_consistency_explicit || @explicit_modes.nil?
           # `--all --persistence-parity` forces the wave on regardless of the dial.
           @enabled_modes |= [:persistence_parity] if @force_parity_wave
+          refuse_unrunnable_modes
+        end
+
+        def apply_self_consistency
+          @enabled_modes = @self_consistency ? @enabled_modes | [:self_consistency] : @enabled_modes - [:self_consistency]
+        end
 
-          # Refuse modes with no implementation before claiming, so `resolved modes:` never
-          # advertises coverage nobody wrote.
+        # Refuse modes with no implementation before claiming, so `resolved modes:` never
+        # advertises coverage nobody wrote.
+        def refuse_unrunnable_modes
           unrunnable = @enabled_modes - Hecks::Fuzzing::TargetCapabilities::RUNNABLE_MODES
           return if unrunnable.empty?
 
-          abort "enabled mode(s) #{unrunnable.join(',')} have no implementation in hecks quality_control ask run " \
+          abort "enabled mode(s) #{unrunnable.join(",")} have no implementation in hecks quality_control ask run " \
                 "(Hecks::Fuzzing::TargetCapabilities::RUNNABLE_MODES is what exists). Set them false in " \
                 "qa/settings.yml, or drop them from --modes, until the code lands."
         end

data/lib/hecks/quality_control/cli/qa_sweep/finding_report/shrunk.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaSweep
+      module FindingReport
+        # The shrunk demonstrations of a finding: how far each shrank, the file it was written to
+        # and the steps that remain.
+        module Shrunk
+          private
+
+          def print_shrunk(shrunk, seed)
+            path = write_shrunk!(shrunk, seed)
+            budget = shrunk[:exhausted] ? ", budget exhausted — may shrink further" : ""
+            puts "shrunk:      [#{shrunk[:mode]}] #{shrunk[:original_size]} -> #{shrunk[:steps].size} step(s) " \
+                 "(#{shrunk[:attempts]} candidate checks#{budget})"
+            puts "file:        #{path.delete_prefix("#{@root}/")}"
+            puts "replay:      #{replay_command(shrunk, path)}"
+            print_shrunk_steps(shrunk)
+          end
+
+          def replay_command(shrunk, path)
+            if %i[differential self_consistency].include?(shrunk[:mode]) && @binary
+              "hecks check_conformance domain=#{@domain_path} script=#{path} artifact=#{@binary}"
+            else
+              "hecks run #{@domain_path} #{path}"
+            end
+          end
+
+          def print_shrunk_steps(shrunk)
+            puts "-- shrunk steps [#{shrunk[:mode]}] --"
+            shrunk[:steps].each_with_index do |step, index|
+              kind = %w[verb query dry_run].find { |key| step.key?(key) }
+              puts "#{index}: #{"#{kind} " unless kind == "verb"}#{step[kind]}  args: #{JSON.generate(step["args"])}"
+            end
+            puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_sweep/finding_report.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "finding_report/shrunk"
+
 module Hecks
   module QualityControlCli
     class QaSweep
       # What a sweep prints when a check surprised: the header, the reproduction, every divergence
       # and the generated and shrunk steps, so an agent can decide from the report alone.
       module FindingReport
+        include Shrunk
+
         private
 
         # @param surprise [Hash] the surprising seed's result: `seed`, `steps`, `checks`, `plan` and
@@ -26,6 +30,12 @@ module Hecks
           puts
           puts "=" * 72
           puts "FOUND SOMETHING — sweep #{@sweep_reference} left OPEN, target #{@target_reference} SUSPENDED."
+          print_finding_instructions
+          puts "=" * 72
+          puts
+        end
+
+        def print_finding_instructions
           puts "No Bug was logged (that needs a real failing-test demonstration, which"
           puts "needs judgment this script does not have — hecks quality_control log is the door)"
           puts "and the sweep was not concluded. The ledger's own SuspendOnSurprise"
@@ -35,29 +45,37 @@ module Hecks
           puts "An agent decides from here: self-contained fix with a regression test"
           puts "and a PR (hecks quality_control patch.open), or a Bug left open for something bigger."
           puts "Never waived here, never filed upstream from here."
-          puts "=" * 72
-          puts
         end
 
         def print_finding_facts(surprise)
+          print_identity_facts
+          print_run_facts(surprise)
+          print_reproduction(surprise) if surprise[:seed]
+          puts "surprised:   #{surprise[:checks].map { |c| c[:mode] }.join(", ")}"
+          puts
+        end
+
+        def print_identity_facts
           puts "domain:      #{@target_path} (#{@domain_path})"
           puts "target:      #{@target_reference}"
           puts "sweep:       #{@sweep_reference} (id #{@sweep.id})"
-          puts "mode:        #{@mode} (active modes: #{@active_modes.join(', ')}; " \
-               "capabilities: #{@capabilities.join(', ')})"
-          puts "seed:        #{surprise[:seed] || 'n/a (once-per-sweep check)'}"
+          puts "mode:        #{@mode} (active modes: #{@active_modes.join(", ")}; " \
+               "capabilities: #{@capabilities.join(", ")})"
+        end
+
+        def print_run_facts(surprise)
+          puts "seed:        #{surprise[:seed] || "n/a (once-per-sweep check)"}"
           puts "steps:       #{@steps_per_sequence}"
           puts "adversarial: #{@adversarial}"
           puts "role-draw:   #{@role_draw}"
           puts "dry-run:     #{@dry_run}"
           puts "streak:      clean_streak was #{@current_streak} going into this pass"
-          if surprise[:seed]
-            puts "reproduce:   Hecks::Fuzzing::SequenceGenerator.generate(#{@domain_path.inspect}, " \
-                 "seed: #{surprise[:seed]}, steps: #{@steps_per_sequence}, adversarial: #{@adversarial}, " \
-                 "role_draw: #{@role_draw}, dry_run: #{@dry_run}#{plan_arguments(surprise[:plan])})"
-          end
-          puts "surprised:   #{surprise[:checks].map { |c| c[:mode] }.join(', ')}"
-          puts
+        end
+
+        def print_reproduction(surprise)
+          puts "reproduce:   Hecks::Fuzzing::SequenceGenerator.generate(#{@domain_path.inspect}, " \
+               "seed: #{surprise[:seed]}, steps: #{@steps_per_sequence}, adversarial: #{@adversarial}, " \
+               "role_draw: #{@role_draw}, dry_run: #{@dry_run}#{plan_arguments(surprise[:plan])})"
         end
 
         def print_surprised_check(check)
@@ -69,13 +87,15 @@ module Hecks
           # One generic printer for every divergence shape (ruby/rust, memory/postgres_era,
           # live/rehydrated): print every key except the field and the redundant
           # domain/aggregate/type.
-          check[:divergences].each do |divergence|
-            label = [divergence[:field], divergence[:domain], divergence[:aggregate], divergence[:type]]
-                    .compact.join(" ")
-            puts "-- #{label} --"
-            divergence.except(:field, :domain, :aggregate, :type).each { |key, value| puts "#{key}: #{value.inspect}" }
-            puts
-          end
+          check[:divergences].each { |divergence| print_divergence(divergence) }
+        end
+
+        def print_divergence(divergence)
+          label = [divergence[:field], divergence[:domain], divergence[:aggregate], divergence[:type]]
+                  .compact.join(" ")
+          puts "-- #{label} --"
+          divergence.except(:field, :domain, :aggregate, :type).each { |key, value| puts "#{key}: #{value.inspect}" }
+          puts
         end
 
         # Lists every step in order with its `adversarial` metadata, so a divergence's verb matches
@@ -86,28 +106,7 @@ module Hecks
             label = %w[verb query dry_run].filter_map { |key| step[key] if step.key?(key) }.first
             mutation = step["adversarial"] ? JSON.generate(step["adversarial"]) : "(not mutated)"
             puts "#{index}: #{label}  #{mutation}"
-            puts "   args: #{JSON.generate(step['args'])}" if step["adversarial"]
-          end
-          puts
-        end
-
-        def print_shrunk(shrunk, seed)
-          path = write_shrunk!(shrunk, seed)
-          budget = shrunk[:exhausted] ? ", budget exhausted — may shrink further" : ""
-          puts "shrunk:      [#{shrunk[:mode]}] #{shrunk[:original_size]} -> #{shrunk[:steps].size} step(s) " \
-               "(#{shrunk[:attempts]} candidate checks#{budget})"
-          puts "file:        #{path.delete_prefix("#{@root}/")}"
-          replay =
-            if %i[differential self_consistency].include?(shrunk[:mode]) && @binary
-              "hecks check_conformance domain=#{@domain_path} script=#{path} artifact=#{@binary}"
-            else
-              "hecks run #{@domain_path} #{path}"
-            end
-          puts "replay:      #{replay}"
-          puts "-- shrunk steps [#{shrunk[:mode]}] --"
-          shrunk[:steps].each_with_index do |step, index|
-            kind = %w[verb query dry_run].find { |key| step.key?(key) }
-            puts "#{index}: #{"#{kind} " unless kind == 'verb'}#{step[kind]}  args: #{JSON.generate(step['args'])}"
+            puts "   args: #{JSON.generate(step["args"])}" if step["adversarial"]
           end
           puts
         end

data/lib/hecks/quality_control/cli/qa_sweep/parsing/validation.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaSweep
+      module Parsing
+        # The rules for which `QaSweep` flag combinations are refused once every flag is read.
+        module Validation
+          private
+
+          def validate_arguments
+            validate_depth_overrides
+            validate_all_mode
+            force_parity_wave
+            validate_parity_and_release
+          end
+
+          def validate_depth_overrides
+            if @seeds_override && @seeds_override < 1
+              abort "#{USAGE}\n--seeds must be at least 1 — Sweep.Conclude refuses a sweep that checked nothing"
+            end
+            abort "#{USAGE}\n--steps must be at least 1" if @steps_override && @steps_override < 1
+          end
+
+          def validate_all_mode
+            return unless @all_mode && @target_ref
+
+            abort "#{USAGE}\n--all sweeps every waiting target itself — it does not take a target-reference " \
+                  "(got #{@target_ref.inspect})"
+          end
+
+          # `--all --persistence-parity` forces the parity wave on; narrowing every child to that
+          # one mode would abort each ineligible target. A single named target still narrows to that
+          # mode.
+          def force_parity_wave
+            @force_parity_wave = @all_mode && @persistence_parity_mode
+            return unless @force_parity_wave
+
+            @persistence_parity_mode = false
+            @explicit_modes = nil
+          end
+
+          def validate_parity_and_release
+            if @persistence_parity_mode && !@target_ref
+              abort "#{USAGE}\n--persistence-parity needs an explicit target-reference — it never auto-picks " \
+                    "from the rotation, since only a PostgresEra-bound domain gains anything from this " \
+                    "comparison at all (`resolved modes:` on any single-target run says whether a target qualifies)"
+            end
+            validate_release if @release_mode
+            abort "#{USAGE}\n--notes only means something with --release" if @release_notes && !@release_mode
+          end
+
+          def validate_release
+            unless @target_ref
+              abort "#{USAGE}\n--release needs an explicit target-reference — the suspended target a person is " \
+                    "putting back"
+            end
+            unless @release_notes
+              abort "#{USAGE}\n--release needs --notes — what a person concluded is the one thing this script " \
+                    "cannot supply"
+            end
+            return unless @all_mode || @persistence_parity_mode
+
+            abort "#{USAGE}\n--release is its own mode — it does not combine with --all or --persistence-parity"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_sweep/parsing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "parsing/validation"
+
 module Hecks
   module QualityControlCli
     class QaSweep
@@ -10,6 +12,8 @@ module Hecks
       # ledger boots, so `adversarial`, `self_consistency`, `role_draw` and `dry_run` stay nil
       # until then.
       module Parsing
+        include Validation
+
         # Each flag that reads a value, and the setting it fills.
         VALUE_SETTINGS = { "--role-draw" => :role_draw, "--dry-run" => :dry_run, "--adversarial" => :adversarial,
                            "--seeds" => :seeds_override, "--steps" => :steps_override }.freeze
@@ -26,24 +30,31 @@ module Hecks
         # @return [Symbol, nil] `:help` once the usage is printed, else nil
         # @raise [SystemExit] with the usage when a flag or combination is refused
         def parse_arguments(argv)
-          @target_ref = @seeds_override = @steps_override = nil
-          @all_mode = @persistence_parity_mode = @skip_parity_wave = @release_mode = false
-          @adversarial = @self_consistency = @role_draw = @dry_run = nil
-          # `--modes` (or its alias `--persistence-parity`); nil means the dial decides.
-          @explicit_modes = nil
-          @release_notes = nil
+          reset_settings
           until argv.empty?
             arg = argv.shift
-            if %w[-h --help].include?(arg)
-              puts USAGE
-              return :help
-            end
+            return show_usage if %w[-h --help].include?(arg)
+
             parse_flag(arg, argv)
           end
           validate_arguments
           nil
         end
 
+        def reset_settings
+          @target_ref = @seeds_override = @steps_override = nil
+          @all_mode = @persistence_parity_mode = @skip_parity_wave = @release_mode = false
+          @adversarial = @self_consistency = @role_draw = @dry_run = nil
+          # `--modes` (or its alias `--persistence-parity`); nil means the dial decides.
+          @explicit_modes = nil
+          @release_notes = nil
+        end
+
+        def show_usage
+          puts USAGE
+          :help
+        end
+
         def parse_flag(arg, argv)
           if SWITCH_SETTINGS.key?(arg)
             instance_variable_set(:"@#{SWITCH_SETTINGS.fetch(arg)}", true)
@@ -62,20 +73,24 @@ module Hecks
 
         def parse_other_flag(arg, argv)
           case arg
-          when "--persistence-parity"
-            @persistence_parity_mode = true
-            @explicit_modes = %i[persistence_parity]
-          when "--modes"
-            @explicit_modes = parse_modes(argv.shift)
-            @persistence_parity_mode = @explicit_modes == %i[persistence_parity]
-          when "--notes"
-            @release_notes = argv.shift
-            abort "#{USAGE}\n--notes needs the text a person concluded" unless @release_notes
+          when "--persistence-parity" then use_modes(%i[persistence_parity])
+          when "--modes" then use_modes(parse_modes(argv.shift))
+          when "--notes" then read_notes(argv.shift)
           when "--self-consistency" then @self_consistency = parse_boolean(arg, argv.shift)
           else record_target(arg)
           end
         end
 
+        def use_modes(modes)
+          @explicit_modes = modes
+          @persistence_parity_mode = modes == %i[persistence_parity]
+        end
+
+        def read_notes(value)
+          @release_notes = value
+          abort "#{USAGE}\n--notes needs the text a person concluded" unless @release_notes
+        end
+
         def record_target(arg)
           abort "#{USAGE}\nunexpected argument: #{arg.inspect} (target already given: #{@target_ref.inspect})" if @target_ref
 
@@ -88,7 +103,7 @@ module Hecks
 
           known = Hecks::Fuzzing::TargetCapabilities::MODE_REQUIREMENTS.keys
           unknown = names - known
-          abort "#{USAGE}\n--modes names no such mode: #{unknown.join(', ')} (known: #{known.join(', ')})" unless unknown.empty?
+          abort "#{USAGE}\n--modes names no such mode: #{unknown.join(", ")} (known: #{known.join(", ")})" unless unknown.empty?
 
           names
         end
@@ -124,51 +139,6 @@ module Hecks
           else abort "#{USAGE}\n#{flag} must be true or false, got #{value.inspect}"
           end
         end
-
-        def validate_arguments
-          if @seeds_override && @seeds_override < 1
-            abort "#{USAGE}\n--seeds must be at least 1 — Sweep.Conclude refuses a sweep that checked nothing"
-          end
-          abort "#{USAGE}\n--steps must be at least 1" if @steps_override && @steps_override < 1
-          if @all_mode && @target_ref
-            abort "#{USAGE}\n--all sweeps every waiting target itself — it does not take a target-reference " \
-                  "(got #{@target_ref.inspect})"
-          end
-
-          # `--all --persistence-parity` forces the parity wave on; narrowing every child to that
-          # one mode would abort each ineligible target. A single named target still narrows to that
-          # mode.
-          @force_parity_wave = @all_mode && @persistence_parity_mode
-          if @force_parity_wave
-            @persistence_parity_mode = false
-            @explicit_modes = nil
-          end
-          validate_parity_and_release
-        end
-
-        def validate_parity_and_release
-          if @persistence_parity_mode && !@target_ref
-            abort "#{USAGE}\n--persistence-parity needs an explicit target-reference — it never auto-picks " \
-                  "from the rotation, since only a PostgresEra-bound domain gains anything from this " \
-                  "comparison at all (`resolved modes:` on any single-target run says whether a target qualifies)"
-          end
-          validate_release if @release_mode
-          abort "#{USAGE}\n--notes only means something with --release" if @release_notes && !@release_mode
-        end
-
-        def validate_release
-          unless @target_ref
-            abort "#{USAGE}\n--release needs an explicit target-reference — the suspended target a person is " \
-                  "putting back"
-          end
-          unless @release_notes
-            abort "#{USAGE}\n--release needs --notes — what a person concluded is the one thing this script " \
-                  "cannot supply"
-          end
-          return unless @all_mode || @persistence_parity_mode
-
-          abort "#{USAGE}\n--release is its own mode — it does not combine with --all or --persistence-parity"
-        end
       end
     end
   end