hecks 3.5.0 → 3.6.0

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

@@ -4,6 +4,7 @@ require_relative "../../../hecks"
 # The era/lineage plugin has to be loaded before `Hecks.boot` for a real (non-Memory) adapter
 # (ADR 0033).
 require_relative "../../ports/persistence/plugins/era"
+require_relative "qa_seed_angles/seed"
 
 module Hecks
   module QualityControlCli
@@ -11,79 +12,6 @@ module Hecks
     # `Angle` backlog with the practice's starting leads. It is idempotent: only references not
     # already on file are proposed.
     class QaSeedAngles
-      # A `resolution:` present means the lead was already chased down: it is proposed,
-      # investigated and built in one pass. Its absence means the lever is still open.
-      SEED = [
-        {
-          reference:  "ANGLE-1",
-          premise:    "None of BUG#1-5 touched saga/process_manager machinery at all, despite this " \
-                      "session having just built a real one (BugCiWatch) — a stress domain specifically " \
-                      "exercising process-manager correlation, multi-step handler chains, and compensation " \
-                      "legs was a natural, and the highest-priority, next target.",
-          citation:   "BugCiWatch (lib/hecks/quality_control/quality_control.bluebook, \"noticing when a fix " \
-                      "stops holding\"); BUG#1-5, none of which touched saga machinery",
-          proposer:   "Claude QA",
-          resolution: "BUG#6 — SagaInterpreter#qualified cannot tell a same-domain nested-entity " \
-                      "command reference (dispatch Manifest::Slot::Fill) apart from a genuine " \
-                      "cross-domain qualifier, so the leg is silently read as targeting a nonexistent " \
-                      "domain and refuses every time; found by qa/stress_domains/waybill on its first " \
-                      "real run, before fuzzing was even needed. PR #530 (merged)."
-        },
-        {
-          reference: "ANGLE-2",
-          premise:   "nested_pieces (qa/stress_domains/nested_pieces) proves two-level ENTITY nesting " \
-                     "fuzzes and dispatches correctly, but nothing in the corpus exercises deep " \
-                     "reference_to HOPS — a chain of reference-typed lookups across aggregates — or a " \
-                     "governance/authorization-shaped construct combined with existence-checking. Entity " \
-                     "nesting and reference hopping are different DSL mechanisms entirely (entity " \
-                     "addressing vs CommandRules::References#resolve_references / " \
-                     "resolve_state_references), and ADR 0037's own Finding 5 already shows reference " \
-                     "resolution is exactly the kind of place Ruby and Rust structurally diverge — a " \
-                     "stress domain built around multi-hop references, or a scope/authorization check " \
-                     "combined with existence-checking, is a genuinely different construct combination " \
-                     "from anything the six bugs found this session actually touched.",
-          citation:  "qa/stress_domains/nested_pieces (entity nesting, not reference hops); " \
-                     "docs/decisions/0037-generated-sequence-fuzz-bridge-found-real-gaps-two-fixed-" \
-                     "three-catalogued.md, Finding 5 (resolve_state_references never ported to Rust)",
-          proposer:  "Claude QA"
-        },
-        {
-          reference: "ANGLE-3",
-          premise:   "BUG#1/#3/#4 were specifically ENGINE-DIVERGENCE bugs — Ruby and Rust disagreeing " \
-                     "on the same dispatch — a class Ruby-only property/exception fuzzing structurally " \
-                     "cannot see, because there is no second engine to disagree with. " \
-                     "spec/rust_conformance_fuzz_spec.rb's own DOMAINS list wires up only pizzas and " \
-                     "banking for CI-gated differential fuzzing. rust/Cargo.toml already declares " \
-                     "compiled-binary features for compliance and roster (plus meta) that " \
-                     "sit unused for this purpose; examples/chess and examples/directory have no Cargo " \
-                     "feature at all — `hecks project_rust` has never regenerated a binary for either. " \
-                     "Widening either list would let differential fuzzing catch a whole bug class " \
-                     "Ruby-only fuzzing cannot, on domains the practice already owns.",
-          citation:  "BUG#1/#3/#4 (engine-divergence bugs); spec/rust_conformance_fuzz_spec.rb DOMAINS " \
-                     "(pizzas/banking only); rust/Cargo.toml [features] (compliance/roster/" \
-                     "meta have binaries and are not wired in; chess/directory have no feature at all)",
-          proposer:  "Claude QA"
-        },
-        {
-          reference: "ANGLE-4",
-          premise:   "lib/hecks/bluebook/model_check.rb's ALLOWED_FINDINGS, " \
-                     "spec/fuzzing/meta_domain_coverage_spec.rb's META_DOMAIN_GUARANTEED_BY_CONSTRUCTION " \
-                     "and META_DOMAIN_KNOWN_GAPS, and ADR 0037's own catalogued Findings 3-5 are all " \
-                     "places where something once labeled 'known, not a bug' could be re-examined — a " \
-                     "gap accepted a year ago is not guaranteed to still be the right call once the " \
-                     "surrounding code has moved. This session's own waybill finding (BUG#6) confirmed a " \
-                     "SECOND instance of exactly the family ALLOWED_FINDINGS[\"quality_control\"] already " \
-                     "named once (Naming.command_ref's bare-constant rewrite conflating a genuine " \
-                     "cross-domain qualifier with mere nesting) — proof the allowlists are themselves a " \
-                     "live source of leads, not just a static ledger of settled questions.",
-          citation:  "lib/hecks/bluebook/model_check.rb ALLOWED_FINDINGS; " \
-                     "spec/fuzzing/meta_domain_coverage_spec.rb META_DOMAIN_GUARANTEED_BY_CONSTRUCTION / " \
-                     "META_DOMAIN_KNOWN_GAPS; docs/decisions/0037-generated-sequence-fuzz-bridge-found-" \
-                     "real-gaps-two-fixed-three-catalogued.md Findings 3-5",
-          proposer:  "Claude QA"
-        }
-      ].freeze
-
       # Proposes the leads the ledger lacks.
       #
       # @param root [String] the repository root, where `qa/bluebook` is the ledger
@@ -104,12 +32,7 @@ module Hecks
       # @return [Integer] 0 once seeded
       # @raise [SystemExit] when the ledger does not boot
       def call
-        runtime = begin
-          Hecks.boot(@domain_dir)
-        rescue StandardError => e
-          abort "the QualityControl ledger did not boot — fix the ledger itself before seeding it " \
-                "(#{e.class}: #{e.message})"
-        end
+        runtime = boot_ledger
         existing = runtime.query("QualityControl::Angle.All").map { |row| row[:reference][:value] }
         SEED.each do |angle|
           if existing.include?(angle[:reference])
@@ -123,19 +46,23 @@ module Hecks
 
       private
 
+      def boot_ledger
+        Hecks.boot(@domain_dir)
+      rescue StandardError => e
+        abort "the QualityControl ledger did not boot — fix the ledger itself before seeding it " \
+              "(#{e.class}: #{e.message})"
+      end
+
       def propose(angle)
         record = ::QualityControl::Angle.propose!(
           reference: { value: angle[:reference] }, premise: { value: angle[:premise] },
           citation: { value: angle[:citation] }, proposer: { value: angle[:proposer] },
           now: { value: Time.now.to_i }
         )
-        if angle[:resolution]
-          record = record.investigate!
-          record.build!(resolution: { value: angle[:resolution] })
-          @out.puts "proposed, investigated, and built: #{angle[:reference]}"
-        else
-          @out.puts "proposed: #{angle[:reference]}"
-        end
+        return @out.puts "proposed: #{angle[:reference]}" unless angle[:resolution]
+
+        record.investigate!.build!(resolution: { value: angle[:resolution] })
+        @out.puts "proposed, investigated, and built: #{angle[:reference]}"
       end
     end
   end

data/lib/hecks/quality_control/cli/qa_sweep/all_mode/children.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require_relative "../../child"
+
+module Hecks
+  module QualityControlCli
+    class QaSweep
+      module AllMode
+        # The child processes of `--all`: how each one is spawned, and the pool that keeps a bounded
+        # number of them alive at once.
+        module Children
+          # The flags a child sweep is given besides its target and modes: `seeds` and `steps`
+          # forward only when set, so each child derives its own depth from its own streak.
+          ChildFlags = Struct.new(:seeds, :steps, :self_consistency)
+
+          private
+
+          # Spawns `hecks quality_control query sweep.run target=<target>` as a fresh process, not a
+          # fork.
+          def spawn_sweep_child(target_reference, flags, modes:, parity: false)
+            # Unlinked at once: the open fd stays readable, nothing is left on disk, and no fixed
+            # path collides.
+            log = Tempfile.new(["qa_sweep-#{filesystem_safe_component(target_reference)}-", ".log"])
+            log.unlink
+
+            args = child_args(target_reference, flags, modes, parity)
+            pid = Process.spawn(*Child.argv(@root, "qa_sweep", *args), out: log, err: log, chdir: @root)
+            { target: target_reference, pid: pid, log: log }
+          end
+
+          def child_args(target_reference, flags, modes, parity)
+            args = [target_reference]
+            args += ["--seeds", flags.seeds.to_s] if flags.seeds
+            args += ["--steps", flags.steps.to_s] if flags.steps
+            args += ["--adversarial", @adversarial.to_s, "--self-consistency", flags.self_consistency.to_s]
+            args += ["--role-draw", @role_draw.to_s, "--dry-run", @dry_run.to_s]
+            args + (parity ? ["--persistence-parity"] : ["--modes", modes.join(",")])
+          end
+
+          def collect_sweep_child(child, status)
+            child[:log].rewind
+            output = child[:log].read
+            child[:log].close
+
+            { target: child[:target], exit_status: status.exitstatus, termsig: status.termsig, output: output }
+          end
+
+          # Keeps at most `@max_parallel` children alive; results come back in queue order so
+          # reports are stable. The block spawns the child for one target.
+          def run_pool(targets, &)
+            pending = targets.dup
+            running = {}
+            results = {}
+
+            until pending.empty? && running.empty?
+              fill_pool(pending, running, &)
+              reap_child(running, results)
+            end
+
+            targets.map { |target| results.fetch(target) }
+          end
+
+          def fill_pool(pending, running)
+            while running.size < @max_parallel && (next_target = pending.shift)
+              child = yield(next_target)
+              running[child[:pid]] = child
+            end
+          end
+
+          def reap_child(running, results)
+            pid, status = Process.wait2(-1)
+            child = running.delete(pid)
+            results[child[:target]] = collect_sweep_child(child, status) if child
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_sweep/all_mode/report.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaSweep
+      module AllMode
+        # The consolidated report `--all` prints once every wave is done: what each child resolved,
+        # then its operational errors and findings verbatim.
+        module Report
+          # Every child prints one `resolved depth:` line; the child's log is the single source of
+          # truth that the report prints verbatim, so scraping it here cannot disagree.
+          RESOLVED_DEPTH_LINE = /^resolved depth: seeds=(\d+) steps=(\d+) \(clean_streak=(\d+)\)$/
+
+          # Parsed from a child's `resolved modes:` line; wave-2 candidates come from the parent's
+          # own inference, not from this.
+          RESOLVED_MODES_LINE = /^resolved modes: (\S*) \(capabilities=([^;)]*)(?:; deferred=([^)]*))?\)$/
+
+          private
+
+          def resolved_depth_for(output)
+            match = output.match(RESOLVED_DEPTH_LINE)
+            return "depth unknown (target errored before it could claim)" unless match
+
+            "#{match[1]} seeds x #{match[2]} steps (clean streak #{match[3]})"
+          end
+
+          def resolved_modes_for(output)
+            match = output.match(RESOLVED_MODES_LINE)
+            return "modes unknown (target errored before it could resolve them)" unless match
+
+            line = "#{match[1].empty? ? "none" : match[1]} (capabilities: #{match[2].empty? ? "none" : match[2]}"
+            line += "; deferred: #{match[3]}" if match[3] && !match[3].empty?
+            "#{line})"
+          end
+
+          def print_resolved_modes(results)
+            return if results.empty?
+
+            puts
+            puts "resolved modes (by target):"
+            results.each { |r| puts "  #{r[:target]}: #{resolved_modes_for(r[:output])}" }
+          end
+
+          def print_resolved_depths(results)
+            return if results.empty?
+
+            puts
+            puts "resolved depth (by target):"
+            results.each { |r| puts "  #{r[:target]}: #{resolved_depth_for(r[:output])}" }
+          end
+
+          def print_operational_errors(errored)
+            return if errored.empty?
+
+            puts
+            puts "OPERATIONAL ERRORS (#{errored.size}) — read each message, fix the actual problem, don't retry blind:"
+            errored.each do |r|
+              label = r[:exit_status] ? "exit #{r[:exit_status]}" : "killed by signal #{r[:termsig]}"
+              puts
+              puts "-- #{r[:target]} (#{label}) --"
+              puts r[:output].strip
+            end
+          end
+
+          def print_found_something(found)
+            return if found.empty?
+
+            puts
+            puts "FOUND SOMETHING (#{found.size}) — full report per target below; act on every one:"
+            found.each do |r|
+              puts
+              puts "#" * 72
+              puts "# #{r[:target]}"
+              puts "#" * 72
+              puts r[:output]
+            end
+          end
+
+          def print_all_mode_report(results, elapsed, clean, found, errored)
+            print_all_mode_header(results, elapsed)
+            puts "clean (#{clean.size}): #{clean.empty? ? "none" : clean.map { |r| r[:target] }.join(", ")}"
+            print_resolved_depths(results)
+            print_resolved_modes(results)
+            print_operational_errors(errored)
+            print_found_something(found)
+            print_trace_output(results)
+          end
+
+          def print_all_mode_header(results, elapsed)
+            puts "=" * 72
+            puts "CONSOLIDATED REPORT — #{results.size} target(s) swept, #{elapsed.round(1)}s wall-clock " \
+                 "(genuinely parallel — not the sum of every target's own sweep time)"
+            puts "=" * 72
+            puts
+          end
+
+          # A clean child's trace would otherwise be discarded; shown only under `QA_SWEEP_TRACE=1`.
+          def print_trace_output(results)
+            return unless @trace_enabled
+            return if results.empty?
+
+            puts
+            puts "QA_SWEEP_TRACE output (by target, in sweep order):"
+            results.each do |r|
+              trace_lines = r[:output].lines.grep(/^\[qa_sweep_trace /)
+              next if trace_lines.empty?
+
+              puts "  #{r[:target]}:"
+              trace_lines.each { |line| puts "    #{line.chomp}" }
+            end
+          end
+
+          # A finding outranks operational errors: 2 if any child found something, else 1 if any
+          # errored.
+          def all_mode_exit_code(found, errored)
+            return EXIT_FOUND_SOMETHING unless found.empty?
+            return EXIT_ERROR unless errored.empty?
+
+            EXIT_OK
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "tempfile"
-require_relative "../child"
+require_relative "all_mode/children"
+require_relative "all_mode/report"
 
 module Hecks
   module QualityControlCli
@@ -12,13 +12,13 @@ module Hecks
       # A child is a fresh process, never a fork: a forked child would share this process's live
       # Postgres socket.
       module AllMode
-        # Every child prints one `resolved depth:` line; the child's log is the single source of
-        # truth that the report prints verbatim, so scraping it here cannot disagree.
-        RESOLVED_DEPTH_LINE = /^resolved depth: seeds=(\d+) steps=(\d+) \(clean_streak=(\d+)\)$/
+        include Children
+        include Report
 
-        # Parsed from a child's `resolved modes:` line; wave-2 candidates come from the parent's own
-        # inference, not from this.
-        RESOLVED_MODES_LINE = /^resolved modes: (\S*) \(capabilities=([^;)]*)(?:; deferred=([^)]*))?\)$/
+        # Said when no clean wave-1 target binds PostgresEra, so there is nothing to compare Memory
+        # to.
+        PARITY_WAVE_SKIPPED = "parity wave: no clean target binds PostgresEra — nothing to compare Memory " \
+                              "against. Skipped."
 
         private
 
@@ -30,38 +30,32 @@ module Hecks
         # @return [Integer] 2 when any child found something, else 1 when any errored, else 0
         def run_all_mode(modes:, parity_wave:, deferred_wave_modes:)
           now = Time.now.to_i
-          waiting = query("Target.Rotation").map { |row| row[:reference][:value] }
-          stale = stale_holds(now)
-          targets = waiting + stale.map { |row| row[:reference][:value] }
-          if targets.empty?
-            puts "rotation is empty — nothing waiting to sweep, and no stale hold to reclaim. Clean no-op."
-            return EXIT_OK
-          end
+          targets, stale = rotation_targets(now)
+          return empty_rotation if targets.empty?
 
           announce_all(targets, stale, modes, now)
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          results = run_pool(targets) do |reference|
-            spawn_sweep_child(reference, @seeds_override, @steps_override, @self_consistency, modes: modes)
-          end
-          results = results.map { |r| r.merge(wave: 1) }
-          results += run_parity_wave(results) if parity_wave
-          # Each enabled deferred mode gets its own wave over wave 1's clean targets.
-          deferred_wave_modes.each do |mode|
-            results += run_deferred_wave(results.select { |r| r[:wave] == 1 }, mode)
-          end
-          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+          results = sweep_in_waves(targets, modes, parity_wave, deferred_wave_modes)
+          report_all_mode(results, Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at)
+        end
 
-          clean = results.select { |r| r[:exit_status] == EXIT_OK }
-          found = results.select { |r| r[:exit_status] == EXIT_FOUND_SOMETHING }
-          errored = results.reject { |r| [EXIT_OK, EXIT_FOUND_SOMETHING].include?(r[:exit_status]) }
-          print_all_mode_report(results, elapsed, clean, found, errored)
-          all_mode_exit_code(found, errored)
+        # @return [Array(Array<String>, Array<Hash>)] the references to sweep, and the stale holds
+        #   among them
+        def rotation_targets(now)
+          waiting = query("Target.Rotation").map { |row| row[:reference][:value] }
+          stale = stale_holds(now)
+          [waiting + stale.map { |row| row[:reference][:value] }, stale]
+        end
+
+        def empty_rotation
+          puts "rotation is empty — nothing waiting to sweep, and no stale hold to reclaim. Clean no-op."
+          EXIT_OK
         end
 
         def announce_all(targets, stale, modes, now)
-          puts "sweeping #{targets.size} target(s), at most #{@max_parallel} at once: #{targets.join(', ')} " \
+          puts "sweeping #{targets.size} target(s), at most #{@max_parallel} at once: #{targets.join(", ")} " \
                "(adversarial fraction #{@adversarial}, self-consistency #{@self_consistency}, " \
-               "role draw #{@role_draw}, dry-run fraction #{@dry_run}, enabled modes #{modes.join(',')})"
+               "role draw #{@role_draw}, dry-run fraction #{@dry_run}, enabled modes #{modes.join(",")})"
           stale.each do |row|
             puts "reclaimed stale hold: #{row[:reference][:value]} (held by #{row[:held_by][:value]}, " \
                  "#{now - row[:claimed_at][:value]}s ago)"
@@ -76,72 +70,44 @@ module Hecks
           query("Target.Held").select { |row| row[:claimed_at][:value] + row[:window][:value] <= now }
         end
 
-        # Spawns `hecks quality_control query sweep.run target=<target>` as a fresh process, not a
-        # fork. Seeds/steps forward only when given, so each child derives its own depth from its
-        # own streak.
-        def spawn_sweep_child(target_reference, seeds_override, steps_override, self_consistency,
-                              modes:, parity: false)
-          # Unlinked at once: the open fd stays readable, nothing is left on disk, and no fixed path
-          # collides.
-          log = Tempfile.new(["qa_sweep-#{filesystem_safe_component(target_reference)}-", ".log"])
-          log.unlink
-
-          args = [target_reference]
-          args += ["--seeds", seeds_override.to_s] if seeds_override
-          args += ["--steps", steps_override.to_s] if steps_override
-          args += ["--adversarial", @adversarial.to_s, "--self-consistency", self_consistency.to_s]
-          args += ["--role-draw", @role_draw.to_s, "--dry-run", @dry_run.to_s]
-          args += parity ? ["--persistence-parity"] : ["--modes", modes.join(",")]
-
-          pid = Process.spawn(*Child.argv(@root, "qa_sweep", *args), out: log, err: log, chdir: @root)
-          { target: target_reference, pid: pid, log: log }
+        # Wave 1 over every target, then the parity wave and each deferred wave.
+        def sweep_in_waves(targets, modes, parity_wave, deferred_wave_modes)
+          flags = ChildFlags.new(@seeds_override, @steps_override, @self_consistency)
+          results = run_pool(targets) { |reference| spawn_sweep_child(reference, flags, modes: modes) }
+          results = results.map { |r| r.merge(wave: 1) }
+          results += run_parity_wave(results) if parity_wave
+          # Each enabled deferred mode gets its own wave over wave 1's clean targets.
+          deferred_wave_modes.each do |mode|
+            results += run_deferred_wave(results.select { |r| r[:wave] == 1 }, mode)
+          end
+          results
         end
 
-        def collect_sweep_child(child, status)
-          child[:log].rewind
-          output = child[:log].read
-          child[:log].close
-
-          { target: child[:target], exit_status: status.exitstatus, termsig: status.termsig, output: output }
+        def report_all_mode(results, elapsed)
+          clean = results.select { |r| r[:exit_status] == EXIT_OK }
+          found = results.select { |r| r[:exit_status] == EXIT_FOUND_SOMETHING }
+          errored = results.reject { |r| [EXIT_OK, EXIT_FOUND_SOMETHING].include?(r[:exit_status]) }
+          print_all_mode_report(results, elapsed, clean, found, errored)
+          all_mode_exit_code(found, errored)
         end
 
-        # Keeps at most `@max_parallel` children alive; results come back in queue order so reports
-        # are stable.
-        def run_pool(targets)
-          pending = targets.dup
-          running = {}
-          results = {}
-
-          until pending.empty? && running.empty?
-            while running.size < @max_parallel && (next_target = pending.shift)
-              child = yield(next_target)
-              running[child[:pid]] = child
-            end
-
-            pid, status = Process.wait2(-1)
-            child = running.delete(pid)
-            next unless child
-
-            results[child[:target]] = collect_sweep_child(child, status)
-          end
-
-          targets.map { |target| results.fetch(target) }
+        # The flags of a later wave's children: the seeds override, no steps override, and no
+        # self-consistency.
+        def later_wave_flags
+          ChildFlags.new(@seeds_override, nil, false)
         end
 
         # Wave 2: `--persistence-parity` children for wave-1 targets that came back clean and infer
         # `postgres_era`. Skipped by `--no-parity` or when `--modes` already named the mode.
         def run_parity_wave(wave1)
           candidates = wave_candidates(wave1, :persistence_parity)
-          if candidates.empty?
-            puts "parity wave: no clean target binds PostgresEra — nothing to compare Memory against. Skipped."
-            return []
-          end
+          return skipped_wave(PARITY_WAVE_SKIPPED) if candidates.empty?
 
           puts
           puts "parity wave: Memory vs real PostgresEra for #{candidates.size} target(s), " \
-               "at most #{@max_parallel} at once: #{candidates.join(', ')}"
+               "at most #{@max_parallel} at once: #{candidates.join(", ")}"
           results = run_pool(candidates) do |reference|
-            spawn_sweep_child(reference, @seeds_override, nil, false, modes: [], parity: true)
+            spawn_sweep_child(reference, later_wave_flags, modes: [], parity: true)
           end
           # Labelled in the target column so every report section tells a wave-2 row from wave 1's.
           results.map { |r| r.merge(wave: 2, target: "#{r[:target]} [parity wave]") }
@@ -151,128 +117,32 @@ module Hecks
         # the clean wave-1 targets whose capabilities make the mode eligible.
         def run_deferred_wave(wave1, mode)
           candidates = wave_candidates(wave1, mode)
-          if candidates.empty?
-            puts "#{mode} wave: no clean target qualifies. Skipped."
-            return []
-          end
+          return skipped_wave("#{mode} wave: no clean target qualifies. Skipped.") if candidates.empty?
 
           puts
-          puts "#{mode} wave: #{candidates.size} target(s), at most #{@max_parallel} at once: #{candidates.join(', ')}"
+          puts "#{mode} wave: #{candidates.size} target(s), at most #{@max_parallel} at once: #{candidates.join(", ")}"
           results = run_pool(candidates) do |reference|
-            spawn_sweep_child(reference, @seeds_override, nil, false, modes: [mode])
+            spawn_sweep_child(reference, later_wave_flags, modes: [mode])
           end
           results.map { |r| r.merge(wave: 2, target: "#{r[:target]} [#{mode} wave]") }
         end
 
+        def skipped_wave(message)
+          puts message
+          []
+        end
+
         # @return [Array<String>] the clean wave-1 targets whose capabilities make `mode` eligible
         def wave_candidates(wave1, mode)
           clean_refs = wave1.select { |r| r[:exit_status] == EXIT_OK }.map { |r| r[:target] }
           rows = query("Target.All").select { |row| clean_refs.include?(row[:reference][:value]) }
-          eligible = rows.select do |row|
-            capabilities = Hecks::Fuzzing::TargetCapabilities.infer(resolve_target_path(row[:path][:value]),
-                                                                    rust_dir: @rust_dir)
-            Hecks::Fuzzing::TargetCapabilities.eligible?(mode, capabilities)
-          end
-          eligible.map { |row| row[:reference][:value] }
-        end
-
-        def resolved_depth_for(output)
-          match = output.match(RESOLVED_DEPTH_LINE)
-          return "depth unknown (target errored before it could claim)" unless match
-
-          "#{match[1]} seeds x #{match[2]} steps (clean streak #{match[3]})"
-        end
-
-        def resolved_modes_for(output)
-          match = output.match(RESOLVED_MODES_LINE)
-          return "modes unknown (target errored before it could resolve them)" unless match
-
-          line = "#{match[1].empty? ? 'none' : match[1]} (capabilities: #{match[2].empty? ? 'none' : match[2]}"
-          line += "; deferred: #{match[3]}" if match[3] && !match[3].empty?
-          "#{line})"
-        end
-
-        def print_resolved_modes(results)
-          return if results.empty?
-
-          puts
-          puts "resolved modes (by target):"
-          results.each { |r| puts "  #{r[:target]}: #{resolved_modes_for(r[:output])}" }
-        end
-
-        def print_resolved_depths(results)
-          return if results.empty?
-
-          puts
-          puts "resolved depth (by target):"
-          results.each { |r| puts "  #{r[:target]}: #{resolved_depth_for(r[:output])}" }
-        end
-
-        def print_operational_errors(errored)
-          return if errored.empty?
-
-          puts
-          puts "OPERATIONAL ERRORS (#{errored.size}) — read each message, fix the actual problem, don't retry blind:"
-          errored.each do |r|
-            label = r[:exit_status] ? "exit #{r[:exit_status]}" : "killed by signal #{r[:termsig]}"
-            puts
-            puts "-- #{r[:target]} (#{label}) --"
-            puts r[:output].strip
-          end
-        end
-
-        def print_found_something(found)
-          return if found.empty?
-
-          puts
-          puts "FOUND SOMETHING (#{found.size}) — full report per target below; act on every one:"
-          found.each do |r|
-            puts
-            puts "#" * 72
-            puts "# #{r[:target]}"
-            puts "#" * 72
-            puts r[:output]
-          end
-        end
-
-        def print_all_mode_report(results, elapsed, clean, found, errored)
-          puts "=" * 72
-          puts "CONSOLIDATED REPORT — #{results.size} target(s) swept, #{elapsed.round(1)}s wall-clock " \
-               "(genuinely parallel — not the sum of every target's own sweep time)"
-          puts "=" * 72
-          puts
-          puts "clean (#{clean.size}): #{clean.empty? ? 'none' : clean.map { |r| r[:target] }.join(', ')}"
-
-          print_resolved_depths(results)
-          print_resolved_modes(results)
-          print_operational_errors(errored)
-          print_found_something(found)
-          print_trace_output(results)
-        end
-
-        # A clean child's trace would otherwise be discarded; shown only under `QA_SWEEP_TRACE=1`.
-        def print_trace_output(results)
-          return unless @trace_enabled
-          return if results.empty?
-
-          puts
-          puts "QA_SWEEP_TRACE output (by target, in sweep order):"
-          results.each do |r|
-            trace_lines = r[:output].lines.grep(/^\[qa_sweep_trace /)
-            next if trace_lines.empty?
-
-            puts "  #{r[:target]}:"
-            trace_lines.each { |line| puts "    #{line.chomp}" }
-          end
+          rows.select { |row| eligible_for?(row, mode) }.map { |row| row[:reference][:value] }
         end
 
-        # A finding outranks operational errors: 2 if any child found something, else 1 if any
-        # errored.
-        def all_mode_exit_code(found, errored)
-          return EXIT_FOUND_SOMETHING unless found.empty?
-          return EXIT_ERROR unless errored.empty?
-
-          EXIT_OK
+        def eligible_for?(row, mode)
+          capabilities = Hecks::Fuzzing::TargetCapabilities.infer(resolve_target_path(row[:path][:value]),
+                                                                  rust_dir: @rust_dir)
+          Hecks::Fuzzing::TargetCapabilities.eligible?(mode, capabilities)
         end
       end
     end