hecks 7.0.0 → 7.1.0

data/lib/hecks/hecks/adapters/main_integration/train.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../console_capture"
+
+module Hecks
+  module Adapters
+    class MainIntegration
+      # The push train's own copy (`~/.claude/hecks-train`), as a boarding uses it: brought up to
+      # origin/main when it has no tracked changes, then asked to board the checkout's main. The
+      # train runs in its own process and store, so what it pushed is read from its answer. The
+      # command line is fixed: no plain push, no force, no skipped hook, no owner override.
+      class Train
+        # Where the train's copy is.
+        ROOT = File.join(Dir.home, ".claude", "hecks-train")
+
+        # The statuses of a boarding the remote holds: pushed now, or carried by an earlier push.
+        BOARDED = %w[pushed carried].freeze
+
+        # Where the launcher's JSON answer starts in what it printed.
+        RECORD_START = /^\{/
+
+        # @param runner [#call] takes `(argv, chdir:)` and answers `[ok, output]`
+        # @param root [String] the train's copy
+        def initialize(runner, root: ROOT)
+          @runner = runner
+          @root = root
+        end
+
+        # Brings the copy up to origin/main, unless it has tracked changes.
+        #
+        # @return [String] where the copy stands, or why it was left
+        def refresh
+          changed = run("git", "status", "--porcelain", "--untracked-files=no").last.strip
+          return "train copy left as it is: it has tracked changes" unless changed.empty?
+
+          fetched = run("git", "fetch", "-q", "origin", "main").first
+          moved = fetched && run("git", "checkout", "-q", "--detach", "FETCH_HEAD").first
+          moved ? "train copy at origin/main" : "train copy left as it is: it could not be refreshed"
+        end
+
+        # @param checkout [String] the checkout whose main is boarded
+        # @return [Array<String>] the command line the boarding runs
+        def command(checkout)
+          [File.join(@root, "exe", "hecks"), "SendTrain.board!", "checkout=#{checkout}", "remote=origin", "branch=main",
+           "--confirm", "--wait"]
+        end
+
+        # @param checkout [String] the checkout whose main is boarded
+        # @return [Hash{String => Object}] the boarding's record as the train answered it
+        # @raise [ConsoleCapture::Failure] when the train refused, faulted or answered unreadably
+        def board(checkout)
+          ok, output = run(*command(checkout))
+          state = record_in(output)
+          return state if ok && BOARDED.include?(state["status"].to_s)
+
+          raise ConsoleCapture::Failure, "the push train did not push: #{state["refusal"] || output.to_s.strip[-300..] || output}"
+        end
+
+        private
+
+        def run(*argv) = @runner.call(argv, chdir: @root)
+
+        def record_in(output)
+          text = output.to_s
+          start = text.index(RECORD_START)
+          start ? JSON.parse(text[start..]).fetch("state", {}) : {}
+        rescue JSON::ParserError
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/main_integration.adapter

@@ -0,0 +1,7 @@
+# Required by name, not relative to this file: a fuzz or model check boots a copy of this directory,
+# and the implementation must load once, from `lib/`, not from the copy.
+require "hecks/hecks/adapters/main_integration"
+
+Hecks.adapter "MainIntegration" do
+  port "Integrating"
+end

data/lib/hecks/hecks/adapters/main_integration.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "hecks/runtime/dispatcher"
+require "hecks/runtime/errors"
+
+module Hecks
+  module Adapters
+    # The `Integrating` port's adapter for `Integration.Advance`: dispatches the next step of every
+    # open MainIntegration run, once. A landed run is verified, a verified one boarded, and a pushed
+    # or watched one has its CI run read. A run in any other stage (being verified or boarded,
+    # green, red, superseded or waiting for a person) is left alone, so a second advance in the
+    # same stage dispatches nothing.
+    #
+    # Each step is a dispatch of its own through the boot whose advance asked, not a dispatch from
+    # inside the saga, so it starts its own reaction chain. A boarding needs the advance's
+    # `confirm`, and waits while another run is being pushed or watched.
+    class MainIntegration
+      # The command each stage's next step dispatches.
+      NEXT = { "landed" => "Verify", "verified" => "Board", "pushed" => "Observe", "ci_running" => "Observe" }.freeze
+
+      # @param registry [Runtime::Registry, nil] the booted registry whose runs are advanced
+      # @param aggregate [Object, nil] unused
+      def initialize(registry: nil, aggregate: nil)
+        @registry = registry
+      end
+
+      # Dispatches each open run's next step.
+      #
+      # @param held [Hash] the `Integration` record: `confirm` lets a verified run board
+      # @return [Hash{Symbol => Hash}] `report:` one line per open run: what was dispatched and
+      #   the stage it left the run in, or why nothing was
+      def step(**held)
+        confirm = plain(held[:confirm]) == true
+        lines = runs.all.select { |run| NEXT.key?(run.state) }.map { |run| advance(run, confirm) }
+        { report: { value: lines.empty? ? "no open integration run" : lines.join("\n") } }
+      end
+
+      private
+
+      def runs = Runs.new(@registry)
+
+      def advance(run, confirm)
+        held_back = boarding_held_back(run, confirm) if NEXT[run.state] == "Board"
+        return "#{run.short} #{run.state}: #{held_back}" if held_back
+
+        dispatch(run, NEXT[run.state], confirm)
+      end
+
+      def boarding_held_back(run, confirm)
+        other = runs.in_flight(except: run.landed).first
+        return "waits for #{other.short}, which is #{other.state}" if other
+        return "would board; advance with --confirm to push main" unless confirm
+
+        nil
+      end
+
+      def dispatch(run, command, confirm)
+        Runtime::Dispatcher.new(@registry).dispatch_flat("Hecks::Integration.#{command}", arguments(run, command, confirm))
+        "#{run.short} #{run.state} -> #{command}: now #{runs.find(run.landed)&.state}"
+      rescue *Runtime::DOMAIN_REFUSALS => e
+        "#{run.short} #{run.state} -> #{command} refused: #{e.message}"
+      end
+
+      def arguments(run, command, confirm)
+        args = { run: SecureRandom.uuid, landed: run.landed }
+        args[:checkout] = run.checkout unless run.checkout.empty?
+        args[:confirm] = true if command == "Board" && confirm
+        args
+      end
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end
+
+require_relative "main_integration/runs"

data/lib/hecks/hecks/adapters/main_verification.adapter

@@ -0,0 +1,7 @@
+# Required by name, not relative to this file: a fuzz or model check boots a copy of this directory,
+# and the implementation must load once, from `lib/`, not from the copy.
+require "hecks/hecks/adapters/main_verification"
+
+Hecks.adapter "MainVerification" do
+  port "MainVerifying"
+end

data/lib/hecks/hecks/adapters/main_verification.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "console_capture"
+require_relative "main_integration"
+require_relative "main_integration/repository"
+require_relative "main_integration/checks"
+require_relative "main_integration/command_runner"
+
+module Hecks
+  module Adapters
+    # The `MainVerifying` port's adapter for `Integration.Verify`: checks a landed commit in a
+    # clean detached copy of it, holding no local Hecks files, by running every check `Checks`
+    # names there. A commit other than the head of local main is answered `superseded` without a
+    # check: the run for the head verifies both. A check that fails refuses the
+    # verification, naming each failing check and what it printed last.
+    class MainVerification
+      # How much of a failing check's output a refusal keeps.
+      TAIL = 400
+
+      class << self
+        # @return [#call, nil] takes `(argv, chdir:)` and answers `[ok, output]`; the command
+        #   runner when nil. A spec replaces it so no check has to run.
+        attr_accessor :runner
+      end
+
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] unused
+      # @param root [String, nil] unused
+      def initialize(aggregate: nil, settings: {}, root: nil)
+        @failures = []
+      end
+
+      # @param held [Hash] the `Integration` record: `landed` and `checkout`
+      # @return [Hash{Symbol => Hash}] `outcome:` (`verified` or `superseded`) and `report:`
+      # @raise [ConsoleCapture::Failure] naming every check that failed
+      def check(**held)
+        landed = plain(held[:landed]).to_s
+        repository = MainIntegration::Repository.new(plain(held[:checkout]) || Dir.pwd)
+        head = repository.main
+        return superseded(landed, head) unless head == landed
+
+        passed = run_checks(repository, landed)
+        answer("verified", "#{landed[0, 10]} verified: #{passed.join(", ")}")
+      end
+
+      private
+
+      def run_checks(repository, landed)
+        changed = repository.changed(repository.remote_main, landed)
+        repository.clean_copy(landed) do |directory|
+          checks = MainIntegration::Checks.new(directory, changed).all
+          failed = checks.reject { |name, argv| record(name, argv, directory) }
+          refuse!(landed) unless failed.empty?
+          checks.map(&:first)
+        end
+      end
+
+      def record(name, argv, directory)
+        ok, output = runner.call(argv, chdir: directory)
+        @failures << "#{name}: #{tail(output)}" unless ok
+        ok
+      end
+
+      def refuse!(landed)
+        raise ConsoleCapture::Failure, "#{landed[0, 10]} failed verification: #{@failures.join("; ")}"
+      end
+
+      def superseded(landed, head)
+        answer("superseded", "#{landed[0, 10]} is not the head of main (#{head[0, 10]}); the run for the head carries it")
+      end
+
+      def answer(outcome, report) = { outcome: { value: outcome }, report: { value: report } }
+
+      def tail(output)
+        text = last_lines(output).split.join(" ")
+        text.length > TAIL ? text[-TAIL..] : text
+      end
+
+      def last_lines(output)
+        lines = output.to_s.strip.lines
+        lines.last(3).join(" ")
+      end
+
+      def runner = self.class.runner || MainIntegration::CommandRunner.new
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end

data/lib/hecks/hecks/adapters/push_recorder.adapter

@@ -0,0 +1,7 @@
+# Required by name, not relative to this file: a fuzz or model check boots a copy of this directory,
+# and the implementation must load once, from `lib/`, not from the copy.
+require "hecks/hecks/adapters/push_recorder"
+
+Hecks.adapter "PushRecorder" do
+  port "PushRecords"
+end

data/lib/hecks/hecks/adapters/push_recorder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "shell"
+require_relative "console_capture"
+
+module Hecks
+  module Adapters
+    # The `PushRecords` port's adapter: records how a boarding of the push train ended in the
+    # boarded checkout, by running that checkout's own launcher with `PushOutcome.record!`.
+    #
+    # The train runs in Memory in a checkout of its own; the boarded checkout's launcher boots that
+    # checkout's domain, whose own overlay says where its records live, so the outcome lands in the
+    # same journal as its landings. It records and decides nothing: the outcome is the run's
+    # status, and a recording that fails is refused, which leaves the push as it was.
+    class PushRecorder
+      # The launcher, relative to the checkout's top directory.
+      LAUNCHER = File.join("exe", "hecks")
+
+      # The fields of the run recorded as they are held, beside the ones the outcome names.
+      COPIED = %i[branch pushed commits].freeze
+
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] `launcher:` the program to run instead of the checkout's own
+      # @param root [String, nil] unused
+      def initialize(aggregate: nil, settings: {}, root: nil)
+        @launcher = settings[:launcher]
+        @shell = Shell.new
+      end
+
+      # @param held [Hash] the `SendTrain` record: `run`, `status`, `checkout`, `branch`, `pushed`,
+      #   `commits`, and `report` or `refusal`
+      # @return [Hash{Symbol => Hash}] `report:` what the checkout's launcher said it recorded
+      # @raise [ConsoleCapture::Failure] when no checkout is named or the launcher refuses
+      def record_outcome(**held)
+        top = top_of(plain(held[:checkout]))
+        result = @shell.capture(*command(top), *arguments(held, top), "--wait", env: bundle(top), chdir: top)
+        raise ConsoleCapture::Failure, "#{top} did not record the push: #{said(result)}" unless recorded?(result)
+
+        { report: { value: "recorded the #{plain(held[:status])} push in #{top}" } }
+      end
+
+      private
+
+      def top_of(checkout)
+        raise ConsoleCapture::Failure, "the boarding names no checkout to record in" if checkout.to_s.empty?
+
+        result = @shell.capture("git", "rev-parse", "--show-toplevel", chdir: checkout)
+        raise ConsoleCapture::Failure, "#{checkout} is not a checkout: #{said(result)}" unless result.ok?
+
+        result.out.strip
+      end
+
+      def command(top) = [@launcher || File.join(top, LAUNCHER)]
+
+      # The checkout's launcher runs as it runs there: on its own Gemfile, not the train's this
+      # process inherited, and with no environment overlay, which would win over the checkout's
+      # own store.
+      def bundle(top)
+        gemfile = @launcher ? {} : { "BUNDLE_GEMFILE" => File.join(top, "Gemfile") }
+        { "HECKS_ENVIRONMENT" => nil, **gemfile }
+      end
+
+      def arguments(held, top)
+        value = held.to_h { |name, field| [name, plain(field)] }
+        report = value[:report].nil? ? value[:refusal] : value[:report]
+        fields = { run: "#{value[:run]}-#{value[:status]}", checkout: File.join(top, ""), outcome: value[:status],
+                   report: report, **value.slice(*COPIED) }
+        ["PushOutcome.record!", *fields.compact.map { |name, field| "#{name}.value=#{field}" }]
+      end
+
+      def recorded?(result) = result.ok? && !result.out.include?('"refusal": "')
+
+      def said(result) = (result.err.strip.empty? ? result.out : result.err).strip[0, 300]
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end

data/lib/hecks/hecks/adapters/red_flag_guard.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "red_flag_marker"
+require_relative "console_capture"
+
+module Hecks
+  module Adapters
+    # What a standing red flag refuses. While the flag stands, nothing lands on main and nothing is
+    # boarded on the push train except a fix for a red Work row: a branch named for a `red-*` row
+    # (with or without a `qa/` lead) lands and records its tip on the flag, and the train carries
+    # only that tip. The refusal names the flag: `main is red: flag <id>`.
+    class RedFlagGuard
+      # The Work rows that say main is red are keyed with this prefix.
+      RED_ROW = "red-"
+
+      # A branch lead the QA loop adds to a row's name.
+      QA_LEAD = "qa/"
+
+      # @param git_dir [String] the repository's common git directory
+      def initialize(git_dir)
+        @marker = RedFlagMarker.new(git_dir)
+      end
+
+      # @param branch [String] the branch about to land on main
+      # @return [void]
+      # @raise [ConsoleCapture::Failure] when a flag stands and the branch is not a red row's fix
+      def landing!(branch)
+        flag = @marker.read
+        return unless flag
+        return if fix?(branch)
+
+        raise ConsoleCapture::Failure, "#{refusal(flag)}; #{branch} is not a fix for a red-* Work row"
+      end
+
+      # Records that a red row's fix landed, so the train may carry main's new tip.
+      #
+      # @param branch [String] the fix's branch
+      # @param tip [String] main's commit after the landing
+      # @return [void]
+      def landed(branch, tip)
+        @marker.fixed!(tip: tip, branch: branch) if @marker.read && fix?(branch)
+      end
+
+      # @param boarded [String] the commit the train would push
+      # @return [void]
+      # @raise [ConsoleCapture::Failure] when a flag stands and the commit is not the fix's tip
+      def boarding!(boarded)
+        flag = @marker.read
+        return unless flag
+        return if flag["fix_tip"] && flag["fix_tip"] == boarded
+
+        raise ConsoleCapture::Failure, "#{refusal(flag)}; only the tip of a red-* row's fix is boarded"
+      end
+
+      private
+
+      def fix?(branch) = branch.to_s.delete_prefix(QA_LEAD).start_with?(RED_ROW)
+
+      def refusal(flag) = "main is red: flag #{flag["id"]}"
+    end
+  end
+end

data/lib/hecks/hecks/adapters/red_flag_marker.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "fileutils"
+
+module Hecks
+  module Adapters
+    # The standing red flag of one repository: a JSON file in its common git directory that exists
+    # while main is red. Landing and the push train read it, so every worktree of the
+    # repository sees the same flag and a spec's temporary repository never sees the owner's.
+    #
+    # The file holds the flag id, the main commit and CI run that raised it, the failed jobs, the
+    # red Work rows, every later red run, who checked in and what they took, and the tip of the
+    # last fix landed while the flag stood. Clearing removes the file.
+    class RedFlagMarker
+      # The marker's file name, in the common git directory.
+      FILE = "hecks-red-flag.json"
+
+      # @param git_dir [String] the repository's common git directory
+      # @param clock [#call] answers the current Time
+      def initialize(git_dir, clock: -> { Time.now })
+        @path = File.join(git_dir, FILE)
+        @clock = clock
+      end
+
+      # @return [Hash, nil] the standing flag, or nil when main is not flagged
+      def read
+        JSON.parse(File.read(@path)) if File.exist?(@path)
+      rescue JSON::ParserError
+        { "id" => "unreadable", "commit" => "unknown", "runs" => [], "checkins" => [] }
+      end
+
+      # Raises the flag, or records another red run on the standing one.
+      #
+      # @param commit [String] the main commit whose CI run was red
+      # @param run [Hash] `ci_run:`, `jobs:`, `rows:` of that run
+      # @return [Array(Symbol, Hash)] `:raised` or `:noted`, and the flag
+      def raise!(commit:, run:)
+        flag = read
+        return [:raised, write(fresh(commit, run))] unless flag
+
+        flag["runs"] << sighting(commit, run)
+        [:noted, write(flag)]
+      end
+
+      # @param session [String] who checks in
+      # @param taking [String] the Work row or cause they take
+      # @return [Hash, nil] the flag after the check-in, or nil when none stands
+      def check_in!(session:, taking:)
+        flag = read
+        return unless flag
+
+        flag["checkins"] << { "session" => session, "taking" => taking, "at" => stamp }
+        write(flag)
+      end
+
+      # Records the main tip a red-row fix landed at, so the train may board it.
+      #
+      # @param tip [String] the commit main points at after the fix landed
+      # @param branch [String] the fix's branch
+      # @return [Hash, nil] the flag, or nil when none stands
+      def fixed!(tip:, branch:)
+        flag = read
+        return unless flag
+
+        flag["fix_tip"] = tip
+        flag["fix_branch"] = branch
+        write(flag)
+      end
+
+      # Lowers the flag.
+      #
+      # @return [Hash, nil] the flag that was standing, or nil when none was
+      def clear!
+        flag = read
+        File.delete(@path) if flag
+        flag
+      end
+
+      private
+
+      def fresh(commit, run)
+        { "id" => "flag-#{commit.to_s[0, 10]}", "commit" => commit, "raised_at" => stamp, "runs" => [sighting(commit, run)],
+          "checkins" => [] }
+      end
+
+      def sighting(commit, run)
+        { "commit" => commit, "ci_run" => run[:ci_run].to_s, "jobs" => run[:jobs].to_s, "rows" => run[:rows].to_s, "at" => stamp }
+      end
+
+      def write(flag)
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.write(@path, JSON.pretty_generate(flag))
+        flag
+      end
+
+      def stamp = @clock.call.utc.iso8601
+    end
+  end
+end

data/lib/hecks/hecks/adapters/red_flag_report.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Hecks
+  module Adapters
+    # Says a standing red flag in words: its id, the commit, how long main has been red, the failed
+    # jobs, and who has checked in to help and what they took. The pipeline board and the status
+    # query print the same sentence.
+    class RedFlagReport
+      # @param flag [Hash] the marker's content
+      # @param now [Time] the time the elapsed red time is measured to
+      def initialize(flag, now: Time.now)
+        @flag = flag
+        @now = now
+      end
+
+      # @return [Integer] seconds main has been red
+      def elapsed_seconds
+        [(@now - Time.iso8601(@flag.fetch("raised_at"))).to_i, 0].max
+      rescue ArgumentError, KeyError
+        0
+      end
+
+      # @return [String] the whole sentence, one line per fact
+      def text
+        [headline, jobs_line, rows_line, *helper_lines].compact.join("\n")
+      end
+
+      # @return [String] the one-line form for a tile
+      def headline
+        "main is red: #{@flag["id"]} at #{@flag["commit"].to_s[0, 10]}, red for #{elapsed_seconds / 60} min, " \
+          "#{@flag["runs"].to_a.size} red run(s), #{@flag["checkins"].to_a.size} helping"
+      end
+
+      private
+
+      def jobs_line
+        jobs = seen("jobs")
+        "failing jobs: #{jobs.join("; ")}" unless jobs.empty?
+      end
+
+      def rows_line
+        rows = seen("rows")
+        "red rows: #{rows.join(", ")}" unless rows.empty?
+      end
+
+      # The distinct, non-empty values of one field across the red runs.
+      def seen(field)
+        values = @flag["runs"].to_a.map { |run| run[field].to_s }
+        values.reject(&:empty?).uniq
+      end
+
+      def helper_lines
+        @flag["checkins"].to_a.map { |entry| "helping: #{entry["session"]} takes #{entry["taking"]}" }
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/red_flag_survey.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "console_capture"
+require_relative "main_integration/command_runner"
+
+module Hecks
+  module Adapters
+    # Reads the newest CI run of a push to main through `gh` and says whether main is red, green or
+    # still being judged.
+    class RedFlagSurvey
+      # The workflow whose run is read.
+      WORKFLOW = "CI"
+
+      # Job conclusions that are not a failure.
+      CLEAN = %w[success skipped neutral].freeze
+
+      # @param runner [#call, nil] takes `(argv, chdir:)` and answers `[ok, output]`
+      # @param checkout [String] a directory in the repository
+      def initialize(runner:, checkout:)
+        @runner = runner || MainIntegration::CommandRunner.new
+        @checkout = checkout
+      end
+
+      # @return [Hash] `verdict:` (`:red`, `:green` or `:running`), `commit:` and `detail:` in the
+      #   words `RedFlagging` reads a run id and failed jobs from
+      # @raise [ConsoleCapture::Failure] when `gh` cannot be read
+      def latest
+        run = gh("run", "list", "--workflow", WORKFLOW, "--branch", "main", "--event", "push", "--limit", "1",
+                 "--json", "databaseId,status,conclusion,headSha").first
+        return { verdict: :running, commit: "", detail: "no #{WORKFLOW} run of main yet" } unless run
+        return running(run) unless run["status"] == "completed"
+
+        judged(run)
+      end
+
+      private
+
+      def running(run) = { verdict: :running, commit: run["headSha"], detail: "run #{run["databaseId"]} is #{run["status"]}" }
+
+      def judged(run)
+        id = run["databaseId"]
+        return { verdict: :green, commit: run["headSha"], detail: "run #{id} passed" } if run["conclusion"] == "success"
+
+        said = "#{run["headSha"][0, 10]}: run #{id} #{run["conclusion"]}; failed jobs: #{failed(id)}"
+        { verdict: :red, commit: run["headSha"], detail: said }
+      end
+
+      def failed(id)
+        jobs = gh("run", "view", id.to_s, "--json", "jobs").fetch("jobs", [])
+        names = jobs.reject { |job| CLEAN.include?(job["conclusion"].to_s) }.map { |job| job["name"] }
+        names.empty? ? "none named" : names.join(", ")
+      end
+
+      def gh(*args)
+        ok, output = @runner.call(["gh", *args], chdir: @checkout)
+        raise ConsoleCapture::Failure, "gh #{args.first(2).join(" ")} failed: #{output.to_s.strip}" unless ok
+
+        JSON.parse(output)
+      rescue JSON::ParserError
+        raise ConsoleCapture::Failure, "gh #{args.first(2).join(" ")} answered no JSON"
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/red_flagging.adapter

@@ -0,0 +1,7 @@
+# Required by name, not relative to this file: a fuzz or model check boots a copy of this directory,
+# and the implementation must load once, from `lib/`, not from the copy.
+require "hecks/hecks/adapters/red_flagging"
+
+Hecks.adapter "RedFlagging" do
+  port "Flagging"
+end