hecks 6.0.0 → 7.0.0

data/lib/hecks/fuzzing/isolated_boot/postgres_scratch.rb

@@ -53,14 +53,16 @@ module Hecks
         # scratch constant here — `database:`/`schema:` are required keyword args because
         # the caller (`hecks quality_control query sweep.run --persistence-parity`) owns that
         # database's lifecycle.
-        def rebind_to_postgres_era!(copy, database:, schema:)
+        def rebind_to_postgres_era!(copy, database:, schema:, disposable: true)
           require "pg"
           require_owned_scratch!(database, schema)
 
           rewrite_bindings!(copy, "PostgresEra")
           ensure_postgres_era_schema!(database: database, schema: schema)
 
-          write_worlds!(copy, "hecks_fuzz_postgres_era.world") { |name| postgres_era_world(name, database, schema) }
+          write_worlds!(copy, "hecks_fuzz_postgres_era.world") do |name|
+            postgres_era_world(name, database, schema, disposable: disposable)
+          end
           write_unbound_bluebook_worlds!(copy)
         end
 
@@ -73,18 +75,14 @@ module Hecks
                 "There is no shared default, unlike :postgres, so the caller cannot forget to own the lifecycle."
         end
 
-        # The world text for one bluebook on `PostgresEra`.
+        # The world text for one bluebook on `PostgresEra`, in a throwaway schema the caller owns.
         #
-        # `schema:` isolates one ephemeral boot from the next, the same job
-        # `ScratchSchema#scratch_schema` does for `:postgres` (`connect_for` idempotently
-        # creates it; `ensure_postgres_era_schema!` only needs to drop it first).
+        # `allow_superuser true` is deliberate: the era write-fence is row-level security, which a
+        # superuser bypasses, and the fence is not under test here.
         #
-        # `allow_superuser true` is deliberate: PostgresEra normally refuses to boot as
-        # a superuser (its era write-fence is row-level security, which a superuser
-        # bypasses), to protect a real ledger from stale writes. This is a throwaway
-        # schema the caller creates and drops, comparing Memory against PostgresEra's
-        # SQL — the era fence isn't under test, so opting in here is safe.
-        def postgres_era_world(name, database, schema)
+        # The ledger is disposable unless the caller holds the first era itself and wants the
+        # era guard (`disposable: false`).
+        def postgres_era_world(name, database, schema, disposable: true)
           <<~WORLD
             Hecks.world "#{name}" do
               default_adapter "PostgresEra"
@@ -92,6 +90,7 @@ module Hecks
                 database "#{database}"
                 schema "#{schema}"
                 allow_superuser true
+                #{"disposable_ledger true" if disposable}
               end
             end
           WORLD

data/lib/hecks/fuzzing/isolated_boot/worlds.rb

@@ -58,18 +58,36 @@ module Hecks
         # blocks (e.g. `context_map.hecksagon` beside the main one) across sibling files
         # in the same directory, and a second `File.write` to the same path would drop
         # the first file's names.
+        #
+        # A directory that holds the hecksagon named for it (`ask_policy/ask_policy.hecksagon`) may
+        # be loaded as a module folder of its parent, which reads only the `.world` named for the
+        # folder: the world takes that name there.
         def write_worlds!(copy, world_file, &world_for)
-          hecksagon_names_by_dir(copy).each do |dir, names|
-            next if names.empty?
-
-            File.write(File.join(dir, world_file), names.uniq.map(&world_for).join("\n"))
+          written = hecksagon_names_by_dir(copy).filter_map do |dir, names|
+            write_world(dir, names, world_file, &world_for)
           end
 
           Dir.glob(File.join(copy, "**", "*.world")).each do |path|
-            File.delete(path) unless File.basename(path) == world_file
+            File.delete(path) unless written.include?(path) || File.basename(path) == world_file
           end
         end
 
+        # Writes `dir`'s world for `names`, and answers its path; nil when no hecksagon is named.
+        def write_world(dir, names, world_file, &world_for)
+          return if names.empty?
+
+          File.join(dir, world_file_for(dir, world_file)).tap do |path|
+            File.write(path, names.uniq.map(&world_for).join("\n"))
+          end
+        end
+
+        # The file `dir`'s world is written to: `world_file`, or the folder's own name when its
+        # hecksagon carries that name.
+        def world_file_for(dir, world_file)
+          name = File.basename(dir)
+          File.exist?(File.join(dir, "#{name}.hecksagon")) ? "#{name}.world" : world_file
+        end
+
         # The `Hecks.hecksagon` names declared in each directory under `copy`.
         def hecksagon_names_by_dir(copy)
           names_by_dir = Hash.new { |hash, dir| hash[dir] = [] }

data/lib/hecks/fuzzing/isolated_boot.rb

@@ -52,7 +52,7 @@ module Hecks
         when :memory       then rebind_to_memory!(copy)
         when :sqlite       then rebind_to_sqlite!(copy)
         when :postgres     then rebind_to_postgres!(copy, **scratch)
-        when :postgres_era then rebind_to_postgres_era!(copy, database: database, schema: schema)
+        when :postgres_era then rebind_to_postgres_era!(copy, database: database, schema: schema, **scratch)
         else raise ArgumentError,
                    "unknown fuzz adapter #{adapter.inspect} — :memory, :sqlite, :postgres, or :postgres_era"
         end

data/lib/hecks/fuzzing/mutation/checks.rb

@@ -1,4 +1,4 @@
-require_relative "../../cli/run"
+require_relative "../../tools/run"
 require_relative "../../behaviors"
 require_relative "observation"
 require_relative "../../text"
@@ -48,13 +48,13 @@ module Hecks
         # The report `hecks run` would print for the script.
         def corpus_report(domain, corpus)
           IsolatedBoot.call(domain) do |copy|
-            CLI::Run.execute(Hecks.boot(copy, environment: nil), corpus.fetch("steps"))
+            Tools::Run.execute(Hecks.boot(copy, environment: nil), corpus.fetch("steps"))
           end
         end
 
         # @return [String, nil] the first expectation of the script the report does not meet
         def unmet_expectation(corpus, report)
-          unmet = CLI::RunExpectations.unmet(corpus["expectations"] || {}, report).first
+          unmet = Tools::RunExpectations.unmet(corpus["expectations"] || {}, report).first
           unmet && unmet.lines.first.strip
         end
 

data/lib/hecks/grammar/translation.bluebook

@@ -25,7 +25,7 @@ Hecks.bluebook "Translation" do
     value_object "Kind" do
       attribute :value, String,
                 one_of: ["rename", "move", "convert", "drop", "retype", "retired", "derive", "rekey_to",
-                         "backfill", "unresolved"]
+                         "backfill", "split", "unresolved"]
     end
 
     value_object "SourcePath" do

data/lib/hecks/grammar/translation_rules.json

@@ -578,6 +578,70 @@
         }
       }
     },
+    {
+      "verb": "Translation::Rule.Propose",
+      "args": {
+        "kind": {
+          "value": "split"
+        },
+        "source": {
+          "value": "split"
+        },
+        "destination": {
+          "value": ""
+        }
+      }
+    },
+    {
+      "verb": "Translation::Rule.Execute",
+      "args": {
+        "source": {
+          "value": "split"
+        },
+        "target": {
+          "value": "postgres"
+        },
+        "form": {
+          "value": "fan-out: the source is chained through the edges before the split, then each row becomes one row per keyed_by value, carrying the named fields; a delete carries through"
+        }
+      }
+    },
+    {
+      "verb": "Translation::Rule.Execute",
+      "args": {
+        "source": {
+          "value": "split"
+        },
+        "target": {
+          "value": "sqlite"
+        },
+        "form": {
+          "value": "fan-out: the source is chained through the edges before the split, then each row becomes one row per keyed_by value, carrying the named fields; a delete carries through"
+        }
+      }
+    },
+    {
+      "verb": "Translation::Rule.Execute",
+      "args": {
+        "source": {
+          "value": "split"
+        },
+        "target": {
+          "value": "in_process"
+        },
+        "form": {
+          "value": "every source row that carries the keyed_by field yields one target row under that value, holding the named fields; a delete removes the target row"
+        }
+      }
+    },
+    {
+      "verb": "Translation::Rule.Admit",
+      "args": {
+        "source": {
+          "value": "split"
+        }
+      }
+    },
     {
       "verb": "Translation::Rule.Propose",
       "args": {

data/lib/hecks/hecks/adapter_words.json

@@ -0,0 +1,7 @@
+{
+  "words": [
+    "git", "github", "cargo", "postgres", "sqlite", "mysql", "pgadmin",
+    "terminal", "shell", "worktree", "worktrees", "rust", "wasm",
+    "docker", "aws", "lambda", "fargate"
+  ]
+}

data/lib/hecks/hecks/adapters/area_overlap.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Hecks
+  module Adapters
+    # When two file areas overlap: the one rule behind a Work row's `area` claim and a Landing's
+    # changed files. An area is a path prefix (`lib/hecks`) or a glob (`lib/**/*.rb`), compared by
+    # whole segments, so `lib/hecks` holds `lib/hecks/a` and not `lib/hecks_extra`.
+    #
+    # It never misses a real overlap; it may report one that is not real. Areas are normalized
+    # first (`//`, `.`, `..`, a trailing `/`, absolute paths made repository-relative, case folded
+    # where the filesystem folds it). Then they overlap unless a segment proves them apart: a
+    # prefix holds everything beneath it, the empty area is the whole repository, `**` stands for
+    # any depth, and a glob without a `/` matches at any depth. A file holds nothing beneath it.
+    module AreaOverlap
+      # Characters that make a segment a glob.
+      WILDCARD = /[*?\[{]/
+
+      # A brace group that holds a `/`, which splitting on `/` would tear apart.
+      SLASHED_BRACE = /\{[^}]*\/[^}]*\}/
+
+      # The segment that stands for any number of directories.
+      ANY = "**"
+
+      # How a single segment glob is matched.
+      MATCHING = File::FNM_EXTGLOB | File::FNM_DOTMATCH
+
+      module_function
+
+      # Whether two areas overlap.
+      #
+      # @param one [String] a path prefix or glob
+      # @param other [String] a path prefix or glob
+      # @param root [String, nil] the repository's top level, to make absolute paths relative
+      # @param file [Boolean] whether `other` is known to be a file, which holds nothing beneath it
+      # @return [Boolean]
+      def overlap?(one, other, root: nil, file: false)
+        folded = fold_case?(root)
+        left = segments(one, root, folded)
+        right = segments(other, root, folded)
+        return true if left.nil? || right.nil?
+
+        file ? meet?(left, right, leaf: true) : meet?(left, right)
+      end
+
+      # The first pair of paths, one from each list, that overlap.
+      #
+      # @param mine [Array<String>] areas or file paths
+      # @param theirs [Array<String>] areas or file paths
+      # @param root [String, nil] the repository's top level
+      # @return [Array(String, String), nil] the pair, or nil when none overlap
+      def first_overlap(mine, theirs, root: nil)
+        mine.each do |one|
+          theirs.each { |other| return [one, other] if overlap?(one, other, root: root) }
+        end
+        nil
+      end
+
+      # @return [Array<String>, nil] the normalized segments, nil when the path may be anywhere
+      def segments(path, root, folded)
+        text = path.to_s.strip
+        text = text.downcase if folded
+        return [ANY] if text.match?(SLASHED_BRACE)
+
+        relative = relative_to(text, root, folded)
+        relative && anywhere(collapse(relative.split("/")), relative)
+      end
+
+      # A glob without a `/` matches at any depth, as it does in a git pathspec.
+      def anywhere(parts, text)
+        parts.size == 1 && wild?(parts.first) && !text.include?("/") ? [ANY, parts.first] : parts
+      end
+
+      # @return [String, nil] the path under the repository; nil when it is absolute and could be
+      #   anywhere (no root known); a path outside the root gets a segment no area has
+      def relative_to(text, root, folded)
+        return text unless text.start_with?("/")
+        return nil unless root
+
+        inside = under(text, folded ? root.downcase : root)
+        inside.start_with?("..") ? "/outside/#{text}" : inside
+      end
+
+      # @return [String] the path from `root`; empty for the root itself
+      def under(text, root)
+        found = cleaned(text).relative_path_from(cleaned(root)).to_s
+        found == "." ? "" : found
+      end
+
+      def cleaned(text) = Pathname.new(text).cleanpath
+
+      # @return [Array<String>] the segments without empty and `.` ones, `..` applied
+      def collapse(parts)
+        parts.each_with_object([]) do |part, kept|
+          next if part.empty? || part == "."
+
+          part == ".." ? up(kept) : kept << part
+        end
+      end
+
+      def up(kept)
+        return kept << ".." if kept.empty? || kept.last == ".."
+
+        kept << ANY if kept.pop == ANY
+      end
+
+      # @return [Boolean] whether the filesystem under `root` treats `A` and `a` alike
+      def fold_case?(root)
+        base = root || Dir.pwd
+        swapped = base.swapcase
+        swapped != base && File.exist?(swapped) && File.identical?(swapped, base)
+      rescue SystemCallError
+        false
+      end
+
+      # @param leaf [Boolean] whether `right` is a file, so it holds nothing beneath it
+      # @return [Boolean] whether two segment lists can name a common path
+      def meet?(left, right, leaf: false)
+        return exhausted?(left, right, leaf) if left.empty? || right.empty?
+        return meet?(right, left) if swap?(left, right, leaf)
+        return reaches?(left, right, leaf) if left.first == ANY
+
+        segments_meet?(left.first, right.first) && meet?(left.drop(1), right.drop(1), leaf: leaf)
+      end
+
+      # One list ran out: its path holds the rest, unless that is a file's.
+      def exhausted?(left, right, leaf) = left.empty? || (right.empty? && (!leaf || left.all?(ANY)))
+
+      # Puts a leading `**` on the left.
+      def swap?(left, right, leaf) = !leaf && right.first == ANY && left.first != ANY
+
+      # A leading `**` matches no segment or swallows one of the other list's.
+      def reaches?(left, right, leaf)
+        meet?(left.drop(1), right, leaf: leaf) || meet?(left, right.drop(1), leaf: leaf)
+      end
+
+      def segments_meet?(one, other)
+        return one == other unless wild?(one) || wild?(other)
+        return File.fnmatch?(other, one, MATCHING) if wild?(other) && !wild?(one)
+        return File.fnmatch?(one, other, MATCHING) unless wild?(other)
+
+        beginnings_agree?(one, other)
+      end
+
+      def beginnings_agree?(one, other)
+        left = one.split(WILDCARD, 2).first.to_s
+        right = other.split(WILDCARD, 2).first.to_s
+        left.start_with?(right) || right.start_with?(left)
+      end
+
+      # @return [Boolean] whether the segment is a glob
+      def wild?(segment) = segment.match?(WILDCARD)
+    end
+  end
+end

data/lib/hecks/hecks/adapters/claude_agents.rb

@@ -5,6 +5,7 @@ require_relative "shell"
 require "time"
 require_relative "console_capture"
 require_relative "claude_transcript"
+require_relative "dispatching/settings"
 
 module Hecks
   module Adapters
@@ -28,8 +29,10 @@ module Hecks
       # @param aggregate [Object, nil] unused
       # @param settings [Hash] `command:` the program that starts sessions (default `claude`)
       # @param root [String, nil] unused
-      def initialize(aggregate: nil, settings: {}, root: nil)
+      # @param registry [Runtime::Registry, nil] whose Tickets world names the session environment
+      def initialize(aggregate: nil, settings: {}, root: nil, registry: nil)
         @command = settings[:command] || COMMAND
+        @session = Dispatching::Settings.new(registry)
         @shell = Shell.new
         @transcript = ClaudeTranscript.new(**settings.slice(:projects))
       end
@@ -52,7 +55,7 @@ module Hecks
       # @return [Hash{Symbol => Hash}] `session:` the id the session is known by
       # @raise [ConsoleCapture::Failure] when the command fails or names no session
       def start(**held)
-        result = @shell.capture(*start_arguments(held), chdir: plain(held[:repo]))
+        result = @shell.capture(*start_arguments(held), env: @session.session_environment, chdir: plain(held[:repo]))
         raise ConsoleCapture::Failure, "#{@command} did not start a session: #{result.err.strip}" unless result.ok?
 
         id = result.out[SESSION_ID, 1]
@@ -110,9 +113,11 @@ module Hecks
 
       def start_arguments(held)
         agent = plain(held[:agent])
-        [@command, *(agent ? ["--agent", agent] : []), "--bg", "--", plain(held[:brief])]
+        [*niceness, @command, *(agent ? ["--agent", agent] : []), "--bg", "--", plain(held[:brief])]
       end
 
+      def niceness = @session.nice ? ["nice", "-n", @session.nice.to_s] : []
+
       def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
     end
   end

data/lib/hecks/hecks/adapters/codebase/batch_runs.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "spec_files"
+require_relative "impacted_specs"
+require_relative "run_options"
+require_relative "test_runner"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # What Codebase's `TestSuiteRun` asks to run by file: one example of one file, several
+      # files in one launcher boot, and the files a branch's changes touch.
+      module BatchRuns
+        # The operations this module carries out.
+        OPERATIONS = %w[run_spec_example run_spec_files run_impacted_specs].freeze
+
+        module_function
+
+        # @param operation [String] one of `OPERATIONS`
+        # @param args [Hash] the `TestSuiteRun` record's plain fields
+        # @param tree [Tree] the checkout
+        # @return [String] each file's counts and the total, with the mapping for an impacted run
+        # @raise [ConsoleCapture::Failure] when a file fails or cannot be run
+        def call(operation, args, tree)
+          case operation
+          when "run_spec_example" then spec_example(args, tree)
+          when "run_spec_files" then spec_files(args, tree)
+          else impacted(args, tree)
+          end
+        end
+
+        # @param args [Hash] `file`, `example`, and the arguments that set the specs' variables
+        # @param tree [Tree] the checkout
+        # @return [String] what the runner printed
+        def spec_example(args, tree)
+          TestRunner.new(tree).run(file: args[:file], example: args[:example], env: RunOptions.spec_env(args), tags: args[:tags])
+        end
+
+        # @param args [Hash] `files` (whitespace-separated), `example`, `isolation` and the
+        #   run's variables
+        # @param tree [Tree] the checkout
+        # @return [String] each file's counts and the total
+        def spec_files(args, tree)
+          SpecFiles.new(tree).run(files: args[:files], example: args[:example], isolation: args[:isolation] || "process",
+                                  env: RunOptions.spec_env(args), tags: args[:tags])
+        end
+
+        # @param args [Hash] `base` (`main` when absent), `cap`, `dry`, `isolation`, `example`
+        #   and the run's variables
+        # @param tree [Tree] the checkout
+        # @return [String] the mapping and, unless dry, how each spec file ended
+        def impacted(args, tree)
+          ImpactedSpecs.new(tree).call(base: args[:base] || "main", cap: args[:cap] || ImpactedSpecs::DEFAULT_CAP,
+                                       dry: args[:dry] == true, isolation: args[:isolation] || "process",
+                                       example: args[:example], env: RunOptions.spec_env(args), tags: args[:tags])
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/codebase/changed_specs.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # Which specs a set of changed files runs, by name alone: a changed spec runs itself, and a
+      # changed source file runs the spec of the same name (`lib/x/thing.rb` runs `thing_spec.rb`).
+      #
+      # A file that maps to no spec is reported, not guessed at, so a change to a file no spec
+      # names runs nothing rather than the whole suite.
+      module ChangedSpecs
+        module_function
+
+        # @param changed [Array<String>] the changed files, relative to the folder
+        # @param specs [Array<String>] every spec file of the folder, relative to the folder
+        # @return [Array<String>] the specs to run, sorted and without duplicates
+        def call(changed, specs)
+          by_name = specs.group_by { |spec| File.basename(spec) }
+          changed.flat_map do |file|
+            next [file] if specs.include?(file)
+
+            by_name.fetch("#{File.basename(file, ".rb")}_spec.rb", [])
+          end.uniq.sort
+        end
+
+        # @param changed [Array<String>] the changed files
+        # @param specs [Array<String>] every spec file of the folder
+        # @return [Array<String>] the changed Ruby files that map to no spec, for the report
+        def unmapped(changed, specs)
+          mapped = call(changed, specs)
+          changed.select { |file| file.end_with?(".rb") && !mapped.include?(file) && call([file], specs).empty? }
+        end
+
+        # The files that differ from the ref, tracked and untracked, relative to the folder.
+        #
+        # @param tree [Tree] the folder under git
+        # @param base [String] the ref to compare against
+        # @return [Array<String>] the changed files
+        # @raise [ConsoleCapture::Failure] when git refuses, with what it said
+        def changed_files(tree, base)
+          diff, status = Open3.capture2e("git", "-C", tree.root, "diff", "--name-only", base, "--")
+          raise ConsoleCapture::Failure, diff.strip unless status.success?
+
+          untracked, = Open3.capture2("git", "-C", tree.root, "ls-files", "--others", "--exclude-standard")
+          (diff.lines + untracked.lines).map(&:strip).reject(&:empty?).uniq
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/codebase/codemods.rb

@@ -16,11 +16,12 @@ module Hecks
       # when the request is confirmed.
       module Codemods
         # Every operation this family carries out.
-        OPERATIONS = %w[hoist_local_givens drop_implicit_append_fields].freeze
+        OPERATIONS = %w[hoist_local_givens drop_implicit_append_fields move_former_name].freeze
 
         # The script each operation runs.
         SCRIPTS = { "hoist_local_givens"          => "codemod_hoist_local_givens",
-                    "drop_implicit_append_fields" => "codemod_implicit_append_fields" }.freeze
+                    "drop_implicit_append_fields" => "codemod_implicit_append_fields",
+                    "move_former_name"            => "codemod_move_former_name" }.freeze
 
         module_function
 

data/lib/hecks/hecks/adapters/codebase/conformance.rb

@@ -2,9 +2,11 @@
 
 require_relative "tree"
 require_relative "ruby_child"
+require_relative "launcher_text"
 require "hecks/engine_agreement"
 require "hecks/doc/reference"
 require "hecks/shape_ledger"
+require "hecks/tools/gate_memo/standalone"
 
 module Hecks
   module Adapters
@@ -18,7 +20,8 @@ module Hecks
       # script only reports, and with it the script rewrites the committed matrix and its fixtures.
       module Conformance
         # Every operation this family carries out.
-        OPERATIONS = %w[check_engine_agreement measure_doc_coverage check_shape_ledger argument_gate_matrix].freeze
+        OPERATIONS = %w[check_engine_agreement measure_doc_coverage check_shape_ledger check_command_names
+                        check_workflow_pagination argument_gate_matrix].freeze
 
         module_function
 
@@ -34,6 +37,8 @@ module Hecks
           when "check_engine_agreement" then engine_agreement(tree)
           when "measure_doc_coverage" then doc_coverage(tree)
           when "check_shape_ledger" then shape_ledger(held, tree)
+          when "check_command_names" then LauncherText.command_names(tree)
+          when "check_workflow_pagination" then LauncherText.workflow_pagination(tree)
           else gate_matrix(held, tree)
           end
         end
@@ -64,6 +69,14 @@ module Hecks
         # @return [String] the clean verdict, or what was written
         # @raise [ConsoleCapture::Failure] with each bluebook whose shape moved without an edge
         def shape_ledger(held, tree)
+          return judge_shape_ledger(held, tree) if on?(held[:confirm]) || on?(held[:additive])
+
+          Tools::GateMemo::Standalone.guard(tree.root, "shape_ledger") { judge_shape_ledger(held, tree) }
+        end
+
+        # @return [String] the ledger's verdict, or what it wrote
+        # @raise [ConsoleCapture::Failure] with each bluebook whose shape moved without an edge
+        def judge_shape_ledger(held, tree)
           ShapeLedger.check(tree.path("lib/hecks/hecks"), confirm: on?(held[:confirm]), additive: on?(held[:additive]))
         rescue ShapeLedger::Failure => e
           raise ConsoleCapture::Failure, e.message

data/lib/hecks/hecks/adapters/codebase/corpus_queries.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class SourceTree
+      # The `SourceTree` queries that read the corpus of domains: which have Rust, the order regeneration
+      # walks them in, and what the IR and its propagation touchpoints say. Each is answered through
+      # `corpus`, which the includer provides.
+      module CorpusQueries
+        # @return [Hash] `text:` the feature and directory of every domain with a Rust feature
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def rust_domains(**)
+          { text: corpus("rust_domains", {}) }
+        end
+
+        # @return [Hash] `text:` the directories regeneration walks, in the order it walks them
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def regen_order(**)
+          { text: corpus("regen_order", {}) }
+        end
+
+        # @return [Hash] `text:` whether each generated Rust module is covered
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        # @raise [ConsoleCapture::Failure] when a module is not covered
+        def corpus_rust_coverage(**)
+          { text: corpus("corpus_rust_coverage", {}) }
+        end
+
+        # @param args [Hash] the query's arguments: `names`
+        # @return [Hash] `text:` each IR construct's diff from its meta-domain
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def ir_constructs(**args)
+          { text: corpus("ir_constructs", args) }
+        end
+
+        # @param args [Hash] the query's arguments: `domains`, `meta`
+        # @return [Hash] `text:` the rules declared more than once
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        def ir_duplicates(**args)
+          { text: corpus("ir_duplicates", args) }
+        end
+
+        # @param args [Hash] the query's arguments: `name`, `field`
+        # @return [Hash] `text:` which propagation touchpoints already show the field
+        # @raise [Codebase::Tree::NeedsCheckout] when the tree is not a hecks checkout
+        # @raise [ConsoleCapture::Failure] when the construct is not one
+        def ir_impact(**args)
+          { text: corpus("ir_impact", args) }
+        end
+      end
+    end
+  end
+end