hecks 6.0.0 → 7.0.0

data/lib/hecks/corpus/rust.rb

@@ -23,13 +23,11 @@ module Hecks
     RUST_COVERAGE_PENDING = {}.freeze
 
     # The stamp hecks project_rust writes into metadata.rs, e.g.
-    # `examples/pizzas` or `the self-hosted language (...)`, with any
-    # ` (attaches "X")`/` (attaches "x", from: :vendor)` suffix stripped.
-    SOURCE_STAMP = /
-      GENERATED\ by\ hecks\ project_rust\ —\ (.+?)
-      (?:\ \(attaches\ "\w+"(?:,\ from:\ :vendor)?\))?
-      's\ own\ canonical\ IR,
-    /x
+    # `examples/pizzas` or `the self-hosted language (...)`; a bluebook's is its own name.
+    SOURCE_STAMP = /GENERATED\ by\ hecks\ project_rust\ —\ (.+?)'s\ own\ canonical\ IR,/
+
+    # Raised when a name is not a domain the corpus regenerates; the message lists the valid ones.
+    class UnknownDomain < ArgumentError; end
 
     # The Rust-facing lists: which domains and bluebooks `rust/` carries, read off Cargo's
     # `[features]` and the generated modules rather than typed out by hand. Extended onto
@@ -48,7 +46,7 @@ module Hecks
       BLUEBOOK_NAME = /^\s*Hecks\.bluebook\s+"([^"]+)"/
 
       # The corpus kinds holding bluebooks the gem carries and a hecksagon attaches by name.
-      GEM_BLUEBOOK_KINDS = %i[qa deploy site tickets composer tenancy sme bulk].freeze
+      GEM_BLUEBOOK_KINDS = %i[qa deploy site tickets composer tenancy sme bulk ci_pipeline].freeze
 
       # Every place a Rust-facing domain's own `attaches` attachment could be declared.
       #
@@ -75,7 +73,7 @@ module Hecks
         cargo_features_table(root: root).scan(EMPTY_FEATURE).flatten
       end
 
-      # The feature `hecks project_rust` last wrote as Cargo's `default`.
+      # The feature Cargo's `default` names: the one a corpus run keeps it on.
       #
       # @param root [String] repository root to search under
       # @return [String, nil] the default feature's name, or nil when Cargo.toml
@@ -215,8 +213,8 @@ module Hecks
         members(*GEM_BLUEBOOK_KINDS, root: root).filter_map { |member| File.read(member.path)[BLUEBOOK_NAME, 1] }.uniq
       end
 
-      # The regeneration order the drift check runs, sorted by path — so which
-      # domain wins Cargo's `default` is derived, not hand-picked.
+      # The regeneration order the drift check runs, sorted by path, and the domains a corpus
+      # run declares to `hecks project_rust`.
       #
       # @param root [String] repository root to search under
       # @return [Array<RustDomain>] every Rust domain with a Cargo feature, in regeneration order:
@@ -224,6 +222,24 @@ module Hecks
       def rust_regen_order(root: ROOT)
         rust_domains(root: root)
       end
+
+      # The named domains of the regeneration order, in that order whatever order they are named in.
+      #
+      # @param names [Array<String>, nil] feature names; nil names every domain
+      # @param root [String] repository root to search under
+      # @return [Array<RustDomain>] the named domains, in regeneration order
+      # @raise [UnknownDomain] when a name is not a domain's feature, listing the valid ones
+      def rust_domains_named(names, root: ROOT)
+        order = rust_regen_order(root: root)
+        return order if names.nil?
+
+        unknown = names - order.map(&:feature)
+        unless unknown.empty?
+          raise UnknownDomain, "unknown domain(s) #{unknown.join(", ")}; valid: #{order.map(&:feature).sort.join(", ")}"
+        end
+
+        order.select { |domain| names.include?(domain.feature) }
+      end
     end
   end
 end

data/lib/hecks/corpus/sources.rb

@@ -1,3 +1,4 @@
+require_relative "../module_folders"
 module Hecks
   module Corpus
     # How a domain's hecksagon names a bluebook the gem carries and loads by name, as the QA
@@ -15,7 +16,7 @@ module Hecks
       # @return [Array<String>, nil] `.bluebook` file paths found, or nil when none
       def bluebook_files(domain_path)
         [File.join(domain_path, "bluebook"), domain_path].each do |dir|
-          files = Dir[File.join(dir, "*.bluebook")]
+          files = ModuleFolders.all(dir)
           return files unless files.empty?
         end
         attached_bluebook_files(domain_path)

data/lib/hecks/corpus.rb

@@ -1,5 +1,7 @@
 require_relative "fuzzing/target_capabilities"
 require_relative "corpus/adapters"
+require_relative "corpus/generated_key"
+require_relative "corpus/listing"
 require_relative "corpus/routes"
 require_relative "corpus/rust"
 require_relative "corpus/sources"
@@ -23,6 +25,9 @@ module Hecks
       # The Hecks domain (ADR 0080): its bluebooks share one namespace and one hecksagon, so
       # they load together, as a directory, never file by file.
       hecks:     "lib/hecks/hecks",
+      # The Coder and Fixer domains keep their bluebook beside their hecksagon in their own folder.
+      coder:     "lib/hecks/coder",
+      fixer:     "lib/hecks/fixer",
       # A package vendored via `attaches ... from: :vendor` — nested inside the
       # consuming example's own checkout, not this gem's own framework/bluebook/.
       vendored:  "examples/*/vendor/embryonaut_bluebooks/*"
@@ -32,24 +37,31 @@ module Hecks
     # prefix, so a nested fixture keeps its subdirectory (`eras/base`)
     # and never collides with a same-named file elsewhere in the kind.
     FILE_KINDS = {
-      grammar:   "lib/hecks/grammar/*.bluebook",
-      framework: "lib/hecks/framework/bluebook/*.bluebook",
-      qa:        "lib/hecks/quality_control/*.bluebook",
-      language:  "lib/hecks/language/**/*.bluebook",
-      deploy:    "lib/hecks/deploy/bluebook/*.bluebook",
-      site:      "lib/hecks/site/bluebook/*.bluebook",
-      rails_app: "lib/hecks/rails_app/bluebook/*.bluebook",
-      tickets:   "lib/hecks/tickets/bluebook/*.bluebook",
-      composer:  "lib/hecks/composer/bluebook/*.bluebook",
-      tenancy:   "lib/hecks/tenancy/bluebook/*.bluebook",
-      bulk:      "lib/hecks/bulk/bluebook/*.bluebook",
-      sme:       "lib/hecks/sme/bluebook/*.bluebook",
-      fixture:   "spec/fixtures/**/*.bluebook"
+      grammar:      "lib/hecks/grammar/*.bluebook",
+      framework:    "lib/hecks/framework/bluebook/*.bluebook",
+      qa:           "lib/hecks/quality_control/*.bluebook",
+      language:     "lib/hecks/language/**/*.bluebook",
+      deploy:       "lib/hecks/deploy/bluebook/*.bluebook",
+      site:         "lib/hecks/site/bluebook/*.bluebook",
+      rails_app:    "lib/hecks/rails_app/bluebook/*.bluebook",
+      tickets:      "lib/hecks/tickets/bluebook/*.bluebook",
+      composer:     "lib/hecks/composer/bluebook/*.bluebook",
+      tenancy:      "lib/hecks/tenancy/bluebook/*.bluebook",
+      bulk:         "lib/hecks/bulk/bluebook/*.bluebook",
+      sme:          "lib/hecks/sme/bluebook/*.bluebook",
+      # The CI bluebooks keep their bluebook beside their hecksagon, not under a `bluebook/` folder.
+      # CiPipeline is attachable; CiSpeed boots from its own directory; CiWorkflows is the client
+      # whose rows project into .github/workflows.
+      ci_pipeline:  "lib/hecks/ci_pipeline/*.bluebook",
+      ci_speed:     "lib/hecks/ci_speed/*.bluebook",
+      ci_workflows: "lib/hecks/ci_workflows/*.bluebook",
+      fixture:      "spec/fixtures/**/*.bluebook"
     }.freeze
 
     KINDS = (DIRECTORY_KINDS.keys + FILE_KINDS.keys).freeze
 
     extend Adapters
+    extend Listing
     extend Rust
     extend Sources
     extend Worlds
@@ -68,33 +80,6 @@ module Hecks
       kinds.flat_map { |kind| kind_members(kind, root) }
     end
 
-    # @return [Array<Member>] the members of one kind: a directory each, or a file each
-    # @raise [ArgumentError] if `kind` is not in `KINDS`
-    def kind_members(kind, root)
-      if (glob = DIRECTORY_KINDS[kind])
-        directory_members(kind, root, glob)
-      elsif (glob = FILE_KINDS[kind])
-        file_members(kind, root, glob)
-      else
-        raise ArgumentError, "unknown corpus kind #{kind.inspect} — known: #{KINDS.join(", ")}"
-      end
-    end
-
-    def directory_members(kind, root, glob)
-      directories(root, glob).map { |dir| Member.new(File.basename(dir), kind, dir) }
-    end
-
-    def directories(root, glob) = Dir.glob(File.join(root, glob)).select { |path| File.directory?(path) }.sort
-
-    # The part of a glob before its first wildcard.
-    GLOB_FIXED_PREFIX = /\A[^*]*/
-
-    def file_members(kind, root, glob)
-      prefix = File.join(root, glob[GLOB_FIXED_PREFIX].chomp("/"))
-      Dir.glob(File.join(root, glob))
-         .map { |file| Member.new(file.delete_prefix("#{prefix}/").delete_suffix(".bluebook"), kind, file) }
-    end
-
     # What a boot loads for a member — a directory kind's bluebook
     # directory, or a file kind's own file.
     #
@@ -144,13 +129,14 @@ module Hecks
     end
 
     # Every bootable domain in the project — any directory holding a
-    # `.bluebook` no route sends elsewhere (a `bluebook/` folder stands for its parent).
+    # `.bluebook` no route sends elsewhere (a `bluebook/` folder stands for its parent),
+    # less module folders, which their parent's bluebook stands for.
     #
     # @param root [String] repository root to search under
     # @return [Array<String>] absolute paths of every sweepable domain directory
     def sweepable_domains(root = ROOT)
       Dir.chdir(root) do
-        swept = Dir.glob("**/*.bluebook").reject { |path| route_for(path) }
+        swept = Dir.glob("**/*.bluebook").reject { |path| route_for(path) || module_bluebook?(path) }
         dirs = swept.map { |path| owning_dir(File.dirname(path)) }
         dirs.uniq.sort.map { |dir| File.join(root, dir) }
       end
@@ -159,6 +145,15 @@ module Hecks
     # The domain directory a bluebook directory stands for: a `bluebook/` folder is its parent.
     def owning_dir(dir) = File.basename(dir) == "bluebook" ? File.dirname(dir) : dir
 
+    # A bluebook line that opens a `domain_module`.
+    MODULE_OPENING = /^\s*domain_module\b/
+
+    # Whether a bluebook is a module folder's (ADR 0163): it opens a `domain_module` of the parent's
+    # bluebook, so its folder is no domain on its own and cannot boot alone.
+    def module_bluebook?(path)
+      File.basename(path, ".bluebook") == File.basename(File.dirname(path)) && File.read(path).match?(MODULE_OPENING)
+    end
+
     # Sweepable domains a fuzz cannot boot from its copy, by repo-relative directory, each with
     # the reason. A fuzz boots a tmpdir copy of a domain to isolate its state.
     FUZZ_UNBOOTABLE = {

data/lib/hecks/deprecation.rb

@@ -0,0 +1,23 @@
+module Hecks
+  # Says a deprecation once per process, so a boot that checks twice is not noisy. A bluebook's
+  # `formerly_known_as` is the first: the notice names the world line that replaces it.
+  module Deprecation
+    module_function
+
+    # @param key [Array<String>] what the notice is about, such as the domain and aggregate
+    # @param text [String] the warning
+    # @param err [#puts] where it goes
+    # @return [String, nil] the text when it was said now, nil when it had been said already
+    def once(key, text, err: $stderr)
+      @seen ||= {}
+      return if @seen[key]
+
+      @seen[key] = true
+      err.puts(text)
+      text
+    end
+
+    # Forgets what was said, so a spec can hear a notice again.
+    def forget! = @seen = {}
+  end
+end

data/lib/hecks/doc/reference/readme.rb

@@ -44,7 +44,7 @@ module Hecks
         def diagram_showcase(root)
           lifecycle = File.read(File.join(root, "docs/generated/diagrams/pizzas/Order_lifecycle.mmd")).strip
           <<~MARKDOWN.strip
-            `hecks project_diagrams` reads a booted domain's own declaration and draws it as Mermaid — `<Name>_lifecycle.mmd`, `relationships.mmd`, `dispatch.mmd`, `roles.mmd`, `ports.mmd`, `read_models.mmd`, `<Name>_surface.mmd` (what a command does, and what it writes), `<Name>_saga.mmd`, and `frameworks.mmd`. Nothing hand-drawn — the same reason a domain is data at all. Order's own lifecycle, straight off the bluebook above:
+            `hecks query introspection.project_diagrams` reads a booted domain's own declaration and draws it as Mermaid — `<Name>_lifecycle.mmd`, `relationships.mmd`, `dispatch.mmd`, `roles.mmd`, `ports.mmd`, `read_models.mmd`, `<Name>_surface.mmd` (what a command does, and what it writes), `<Name>_saga.mmd`, and `frameworks.mmd`. Nothing hand-drawn — the same reason a domain is data at all. Order's own lifecycle, straight off the bluebook above:
 
             ```mermaid
             #{lifecycle}

data/lib/hecks/doc/reference/rendering.rb

@@ -36,7 +36,7 @@ module Hecks
 
             *The tables on this page are generated from the language's own
             aggregate-local syntax tables (`lib/hecks/language/**/*.bluebook`)
-            by `hecks language_run.project_reference` — do not edit inside the markers. The prose
+            by `hecks language_run.project_reference!` — do not edit inside the markers. The prose
             between them is hand-written and survives regeneration.*
             #{GENERATED_END}
             #{"\n#{preamble}\n" unless preamble.empty?}
@@ -145,7 +145,7 @@ module Hecks
             # The DSL reference
 
             One page per context — the place in a file where a word may be
-            typed. Generated by `hecks language_run.project_reference` from the Syntax declaration;
+            typed. Generated by `hecks language_run.project_reference!` from the Syntax declaration;
             the prose between the generated markers is hand-written and
             survives regeneration.
 

data/lib/hecks/doc/reference.rb

@@ -10,7 +10,7 @@ module Hecks
   module Doc
     # The DSL reference, projected from the language's own Syntax bluebook so
     # its tables can never drift from the live builders. Regenerate with
-    # `hecks language_run.project_reference`.
+    # `hecks language_run.project_reference!`.
     #
     # README's regions are in `Readme` and the coverage gates in `Coverage`, both extended onto
     # this module; `Harvester` reads committed prose back.

data/lib/hecks/embryonaut_bluebook/manifest.rb

@@ -74,7 +74,7 @@ module Hecks
         dir  = File.join(vendor_dir, name)
         path = File.join(dir, "bluebook.lock")
         unless File.exist?(path)
-          problems << "#{name}: no bluebook.lock (hecks package.vendor #{name}@<version>)"
+          problems << "#{name}: no bluebook.lock (hecks package.vendor! #{name}@<version>)"
           return nil
         end
 

data/lib/hecks/fixer/fixer.bluebook

@@ -0,0 +1,240 @@
+# The fixer: the work of taking a logged bug to a verified fix. QualityControl finds and records
+# bugs; this domain holds the attempts at them, and says what happened through its events.
+# A bug is never written here. QualityControl records each step from the events below.
+
+Hecks.bluebook "Fixer" do
+  vision "A logged bug gets one attempt at a time, each claimed, investigated, fixed and verified on the record, and the bug itself is only ever written by the quality ledger."
+
+  # One attempt at one logged bug. The attempt is keyed by the bug's reference, so there is at most
+  # one attempt for each bug the ledger has logged.
+  aggregate "Attempt" do
+    description "One attempt at one logged bug: who holds it, where the fault is, the commit that fixes it, and what verified it."
+
+    identified_by :reference
+
+    attribute :reference,    BugReference
+    attribute :held_by,      Engineer
+    attribute :claimed_at,   Instant
+    attribute :window,       StaleAfter
+    attribute :site,         BugSite, optional: true
+    attribute :cause,        BugCause, optional: true
+    attribute :commit,       CommitRef, optional: true
+    attribute :verification, Verification, optional: true
+    attribute :reproduction, ReproductionCommand, optional: true
+    attribute :observed,     ReproductionObserved, optional: true
+    attribute :reproduced,   ReproductionResult, optional: true
+    attribute :merged_commit, CommitRef, optional: true
+    attribute :merge_pending, MergePending, optional: true
+
+    value_object "BugReference" do
+      attribute :value, String, matches: :present
+      invariant("a bug is referenced") { !value.to_s.empty? }
+    end
+
+    value_object "BugSite" do
+      attribute :value, String, matches: :present
+      invariant("an investigation names where the bug lives") { !value.to_s.empty? }
+    end
+
+    value_object "BugCause" do
+      attribute :value, String, matches: :present
+      invariant("an investigation says why the code is wrong") { !value.to_s.empty? }
+    end
+
+    # 7 to 40 hex: a fix that lives only in a working tree is not a fix.
+    value_object "CommitRef" do
+      attribute :value, String, matches: :git_sha
+    end
+
+    # What was actually run, e.g. "rspec --order random, 1335 examples, 0 failures, seed 12345":
+    # a count and a seed are checkable, "tests pass" is not.
+    value_object "Verification" do
+      attribute :value, String, matches: :present
+      invariant("a verification says what was actually run") { !value.to_s.empty? }
+    end
+
+    # The exact command or entry point that was run, from the real path a user or caller takes.
+    # Verification must re-run this same text, so a fix that passes only new tests is not verified.
+    value_object "ReproductionCommand" do
+      attribute :value, String, matches: :present
+      invariant("a reproduction names the exact command run") { !value.to_s.empty? }
+    end
+
+    # A short fingerprint or the failing line the real path printed.
+    value_object "ReproductionObserved" do
+      attribute :value, String, matches: :present
+      invariant("a reproduction records what the real path printed") { !value.to_s.empty? }
+    end
+
+    value_object "ReproductionResult" do
+      attribute :value, String, matches: :present
+      invariant("a reproduction either failed or passed") { value == "failed" || value == "passed" }
+    end
+
+    # "yes" while a merged patch is on the record for an attempt that cannot yet record its fix.
+    value_object "MergePending" do
+      attribute :value, String, default: ""
+    end
+
+    value_object "Engineer" do
+      attribute :value, String, default: "nobody"
+    end
+
+    value_object "Instant" do
+      attribute :value, Integer, default: 0
+      invariant("an instant is not before the epoch") { !value.negative? }
+    end
+
+    value_object "StaleAfter" do
+      attribute :value, Integer, default: 900
+      invariant("a staleness window is positive") { value.positive? }
+    end
+
+    # A bug is born logged; each step moves the attempt along the same edges QualityControl uses.
+    lifecycle :status, default: "logged" do
+      transition "Investigate" => "investigating", from: %w[logged investigating]
+      transition "Fix"         => "fixed",         from: "investigating"
+      transition "Verify"      => "verified",      from: "fixed"
+      mark :terminal, "verified"
+    end
+
+    # The attempt is opened by the ledger's `BugLogged`, and nothing else creates one.
+    command "Open" do
+      role "Fixer"
+      goal "Start an attempt at a bug the ledger has logged, so it can be claimed"
+
+      attribute :reference, BugReference
+
+      emits "AttemptOpened"
+    end
+
+    # Same rule as QualityControl's `Bug.Claim`: held by nobody, or stale.
+    command "Claim" do
+      role "Fixer"
+      goal "Take the attempt, or one whose holder has gone quiet"
+
+      reference_to Attempt
+      attribute :reference, BugReference
+      attribute :held_by,   Engineer, sets: true
+      attribute :now,       Instant
+      needs :now
+
+      given("a live claim is not taken from the agent holding it") do
+        held_by.value == "nobody" || claimed_at.value + window.value <= now.value
+      end
+
+      sets :claimed_at, to: :now
+
+      emits "AttemptClaimed"
+    end
+
+    # An investigation starts from the real entry point: the command run, what it printed, and
+    # whether it failed. `Fix` is refused until a failing reproduction is on the record. An
+    # attempt already investigating can be investigated again, to record the reproduction it lacks
+    # or to replace one that did not fail.
+    command "Investigate" do
+      role "Fixer"
+      goal "Run the real entry point, record its failure, name the code that is wrong and say why"
+
+      reference_to Attempt
+      attribute :reference,    BugReference
+      attribute :site,         BugSite,  sets: true
+      attribute :cause,        BugCause, sets: true
+      attribute :reproduction, ReproductionCommand,  sets: true
+      attribute :observed,     ReproductionObserved, sets: true
+      attribute :reproduced,   ReproductionResult,   sets: true
+
+      emits "AttemptInvestigated"
+    end
+
+    # `FixReady` carries the commit that makes the bug stop happening. The ledger records the fixed
+    # state from it, and the commit is what the Clearance check and the saga correlate on.
+    command "Fix" do
+      role "Fixer"
+      goal "Record the commit that makes it stop happening"
+
+      reference_to Attempt
+      attribute :reference, BugReference
+      attribute :commit,    CommitRef, sets: true
+
+      given("no failing reproduction recorded: run the real entry point first") do
+        !reproduction.nil? && !reproduced.nil? && reproduced.value == "failed"
+      end
+
+      emits "FixReady"
+    end
+
+    # A merged patch the attempt cannot yet record as its fix (no failing reproduction on the
+    # record) is kept on the attempt and announced, so it is neither dropped nor silent: the
+    # attempt lists under `AwaitingReproduction` until it is investigated and fixed.
+    command "NoteMerge" do
+      role "Fixer"
+      goal "Keep a merged patch that the attempt cannot yet record as its fix"
+
+      reference_to Attempt
+      attribute :reference, BugReference
+      attribute :commit,    CommitRef
+
+      given("a patch the attempt already recorded as its fix is not pending") do
+        reproduction.nil? || reproduced.nil? || reproduced.value != "failed"
+      end
+
+      sets :merged_commit, to: :commit
+      sets :merge_pending, to: "yes"
+
+      emits "MergeAwaitsReproduction"
+    end
+
+    # The attempts holding a merged patch they could not record: the QA tick reads these, investigates
+    # with a failing reproduction, then records the fix with `merged_commit`.
+    query "AwaitingReproduction" do
+      description "Every attempt with a merged patch it could not record as its fix because no failing reproduction is on the record."
+      where(status: { in: "logged,investigating" }, merge_pending: "yes")
+      order_by :claimed_at
+    end
+
+    # `FixVerified` restates the reference and commit so the ledger can record the verified state
+    # against the bug it names.
+    command "Verify" do
+      role "Fixer"
+      goal "Record that the fix was actually verified, and exactly how"
+
+      reference_to Attempt
+      attribute :reference, BugReference
+      attribute :commit,    CommitRef
+      attribute :evidence,  Verification
+      attribute :rerun,         ReproductionCommand
+      attribute :rerun_result,  ReproductionResult
+
+      given("the reproduction re-run is not the one recorded: run the recorded command") do
+        !reproduction.nil? && rerun.value == reproduction.value
+      end
+
+      given("the recorded reproduction still fails: a fix that passes only new tests is not verified") do
+        rerun_result.value == "passed"
+      end
+
+      sets :verification, to: :evidence
+
+      emits "FixVerified"
+    end
+  end
+
+  # The ledger logged a bug: the attempt at it is opened, ready to be claimed.
+  policy "OpenOnBugLogged" do
+    on      "Bug.BugLogged"
+    trigger Attempt::Open, with: { reference: :reference }
+  end
+
+  # A merged patch is the commit that makes a bug's fix true, so the attempt at it records the fix.
+  policy "FixOnPatchMerged" do
+    on      "Patch.PatchMerged"
+    trigger Attempt::Fix, with: { reference: :bug, commit: :commit }
+  end
+
+  # Declared after the fix: an attempt that could not record it keeps the commit and says so.
+  policy "NoteMergeWhenPatchMerged" do
+    on      "Patch.PatchMerged"
+    trigger Attempt::NoteMerge, with: { reference: :bug, commit: :commit }
+  end
+end

data/lib/hecks/fixer/fixer.hecksagon

@@ -0,0 +1,17 @@
+# The Fixer domain, bound so it boots standing alone (a fuzz or model_check boot of this
+# directory). The attempts are held in Memory here; the ledger's own store is wired by the
+# QualityControl hecksagon.
+Hecks.hecksagon "Fixer" do
+  attaches "Governance"
+  persisted_by "Memory"
+
+  # The ledger's bug being logged, which opens the attempt at it, and a merged patch, which records
+  # the fix. Declarative: QualityControl emits both, and the policies above react.
+  subscribe "QualityControl.BugLogged"
+  subscribe "QualityControl.PatchMerged"
+end
+
+# The anti-corruption layer for Governance, which the bluebook's roles are checked against.
+Hecks.hecksagon "Governance" do
+  persisted_by "Memory"
+end

data/lib/hecks/framework_bluebooks.rb

@@ -6,8 +6,8 @@ require_relative "sentence_form"
 
 module Hecks
   # The bluebooks the gem carries that a hecksagon can attach by name (ADR 0080): the language
-  # declared in itself, Expression, Tenancy, Deploy, Site, Tickets, Composer, QualityControl and
-  # Bulk.
+  # declared in itself, Expression, Tenancy, Deploy, Site, Tickets, Composer, QualityControl,
+  # Fixer, Coder, Bulk and CiPipeline.
   # Framework members stay in `Framework`; `table` and `attach!` find a name across both.
   #
   # A bluebook is named by the `Hecks.bluebook "Name"` header of its files, and may span several.
@@ -18,7 +18,8 @@ module Hecks
     # Where attachable bluebooks live, relative to `lib/hecks/`.
     GLOBS = %w[language/**/*.bluebook grammar/expression.bluebook tenancy/bluebook/*.bluebook
                deploy/bluebook/*.bluebook site/bluebook/*.bluebook rails_app/bluebook/*.bluebook tickets/bluebook/*.bluebook
-               composer/bluebook/*.bluebook quality_control/*.bluebook bulk/bluebook/*.bluebook].freeze
+               composer/bluebook/*.bluebook quality_control/*.bluebook fixer/*.bluebook coder/*.bluebook
+               bulk/bluebook/*.bluebook ci_pipeline/*.bluebook].freeze
 
     # A `Hecks.bluebook "Name"` header line, capturing the bluebook's name.
     BLUEBOOK_HEADER = /\A\s*Hecks\.bluebook\s+"([^"]+)"/
@@ -106,7 +107,7 @@ module Hecks
       Bluebook::MetaValidator.defer { paths.each { |path| SentenceForm.load_file(path) } }
       Bluebook::MetaValidator.judge_deferred!(registry)
       load_wiring(name, paths)
-    rescue Exception # rubocop:disable Lint/RescueException -- rolls back, then re-raises
+    rescue Exception
       roll_back(registry, name, before)
       raise
     end
@@ -140,12 +141,36 @@ module Hecks
     # @param paths [Array<String>] the bluebook's bluebook files
     # @return [void]
     def self.load_wiring(name, paths)
+      wiring_files(name, paths).each { |file| Kernel.load(file) }
+    end
+    private_class_method :load_wiring
+
+    # The files `load_wiring` loads, in the order it loads them: the ports file, then the adapters.
+    #
+    # @param name [String] the bluebook's name
+    # @param paths [Array<String>] the bluebook's bluebook files
+    # @return [Array<String>] the ports file when there is one, then each adapter file
+    def self.wiring_files(name, paths)
       directory = File.dirname(paths.first)
       ports     = File.join(directory, "#{Naming.snake(name)}.ports.hecksagon")
-      Kernel.load(ports) if File.file?(ports)
-      Dir.glob(File.join(directory, "adapters", "*.adapter")).each { |adapter| Kernel.load(adapter) }
+      [*(ports if File.file?(ports)), *Dir.glob(File.join(directory, "adapters", "*.adapter"))]
+    end
+    private_class_method :wiring_files
+
+    # Every file attaching the named bluebook reads: a framework member's one file, or an
+    # attachable bluebook's files with the ports file and adapters it ships. What a cache of a
+    # generated tree hashes to know when attaching the bluebook would write something else.
+    #
+    # @param name [String, Symbol] the bluebook's name, such as `"Governance"`
+    # @return [Array<String>] the files' absolute paths
+    # @raise [Runtime::WiringError] if the gem carries no bluebook of that name
+    def self.files_of(name)
+      key = name.to_s
+      return [Framework.members.fetch(key)] if Framework.members.key?(key)
+
+      paths = bluebook_paths(key)
+      [*paths, *wiring_files(key, paths)]
     end
-    private_class_method :load_wiring
 
     # The name a file's `Hecks.bluebook "Name"` header declares, or nil for a file without one.
     def self.declaration_name(path)

data/lib/hecks/fuzzing/concurrent_dispatch/world_copy.rb

@@ -58,6 +58,7 @@ module Hecks
                 database "#{database}"
                 schema "#{schema}"
                 allow_superuser true
+                disposable_ledger true
               end
             end
           WORLD