hecks 4.0.0 → 6.0.0

data/lib/hecks/composer/toolbox.rb

@@ -4,7 +4,7 @@ require "hecks/composer/parse"
 module Hecks
   module Composer
     # Runs Hecks's own commands and queries in-process for a command palette and an Eras panel.
-    # It is on the hecksagon side like the other composer files: it boots the Hecks chapter once,
+    # It is on the hecksagon side like the other composer files: it boots the Hecks bluebook once,
     # on first use, and sends argv to the CLI runner one call at a time. A command that is not on
     # the safe list is guarded: it runs only when the caller echoes back a confirmation phrase.
     class Toolbox
@@ -16,12 +16,15 @@ module Hecks
         style_run.check_comments style_run.check_rust_comments style_run.check_comments_unchanged
       ].freeze
 
+      # A carriage return or line feed.
+      LINE_BREAK = /[\r\n]/
+
       ERA_QUERIES = {
         shape: "introspection.shape", scaffold_translation: "era.scaffold_translation",
         audit_translation: "era.audit_translation", compaction: "era.compaction"
       }.freeze
 
-      # @return [Toolbox] a toolbox that boots the Hecks chapter on first use
+      # @return [Toolbox] a toolbox that boots the Hecks bluebook on first use
       def initialize
         @lock = Mutex.new
         @runtime = nil
@@ -99,7 +102,7 @@ module Hecks
 
       # @api private
       def newline?(args)
-        args.any? { |name, value| [name, value].any? { |text| text.to_s.match?(/[\r\n]/) } }
+        args.any? { |name, value| [name, value].any? { |text| text.to_s.match?(LINE_BREAK) } }
       end
 
       # @api private
@@ -132,7 +135,7 @@ module Hecks
 
       # @api private
       def verbs(member)
-        chapter.aggregates.flat_map do |aggregate|
+        declaration.aggregates.flat_map do |aggregate|
           aggregate.public_send(member).map do |item|
             ["#{Naming.snake(aggregate.hecks_name)}.#{Naming.snake(item.hecks_name)}", item]
           end
@@ -140,8 +143,8 @@ module Hecks
       end
 
       # @api private
-      def chapter
-        runtime.registry.bluebook("Hecks")
+      def declaration
+        runtime.bluebook("Hecks")
       end
 
       # @api private

data/lib/hecks/composer/web.rb

@@ -138,13 +138,14 @@ module Hecks
       end
 
       def check(body)
-        json(200, Check.call(dir: workspace, buffers: buffers(body), chapter_name: body["chapter_name"]))
+        json(200, Check.call(dir: workspace, buffers: buffers(body), declaration_name: body["bluebook_name"]))
       end
 
       def buffers(body) = body.fetch("buffers", {})
 
       def body(request)
-        raw = request.body&.read.to_s
+        stream = request.body
+        raw = stream&.read.to_s
         raw.empty? ? {} : JSON.parse(raw)
       end
 

data/lib/hecks/composer/workbench.rb

@@ -9,12 +9,22 @@ module Hecks
     # the agent that edits it and the panels beneath the editor. Opening another domain builds a
     # new workbench, so nothing of the old workspace carries over.
     class Workbench
+      # The registry of one agent adapter: the real `claude`, or a scripted `fake`.
+      #
+      # @param name [String, nil] `claude` (the default) or `fake`
+      # @return [Runtime::Registry] a registry holding the `composer_agent` port and that adapter
+      def self.agents_named(name)
+        adapter = name == "fake" ? "fake_agent" : "claude_composer"
+        require_relative "adapters/#{adapter}"
+        Agent.registry_with(File.join(Agent::ADAPTERS, "#{adapter}.adapter"))
+      end
+
       # @return [String] the domain directory this workbench is for
       attr_reader :workspace
 
       # @param workspace [String] the domain directory
       # @param agents [Runtime::Registry, nil] a registry holding the `composer_agent` port and one
-      #   adapter; the one `HECKS_COMPOSER_AGENT` names (`claude`, the default, or `fake`) when nil
+      #   adapter; the real `claude` one when nil
       def initialize(workspace:, agents: nil)
         @workspace = File.expand_path(workspace)
         @agents = agents
@@ -38,14 +48,7 @@ module Hecks
 
       private
 
-      def agents = @agents ||= default_agents
-
-      # The adapter `HECKS_COMPOSER_AGENT` names: the real `claude`, or a scripted `fake`.
-      def default_agents
-        name = ENV.fetch("HECKS_COMPOSER_AGENT", "claude") == "fake" ? "fake_agent" : "claude_composer"
-        require_relative "adapters/#{name}"
-        Agent.registry_with(File.join(Agent::ADAPTERS, "#{name}.adapter"))
-      end
+      def agents = @agents ||= self.class.agents_named("claude")
     end
   end
 end

data/lib/hecks/composer.rb

@@ -11,7 +11,7 @@ require_relative "composer/check"
 
 module Hecks
   # The Composer's outside, on the hecksagon side: staging a workspace, judging its text and
-  # projecting what it declares. The Composer chapter's bluebook is in `composer/bluebook/`.
+  # projecting what it declares. The Composer bluebook's bluebook is in `composer/bluebook/`.
   module Composer
   end
 end

data/lib/hecks/construct.rb

@@ -4,8 +4,8 @@ module Hecks
   #
   # The fully-qualified name walks owners and matches the id `MetaValidator::Judge#identify` mints.
   #
-  #     Pizzas                     the chapter, no owner
-  #     Pizzas::Pizza              an aggregate joins its chapter with ::
+  #     Pizzas                     the bluebook, no owner
+  #     Pizzas::Pizza              an aggregate joins its bluebook with ::
   #     Pizzas::Pizza.Price        everything else joins its owner with .
   #     price = Class.new(ValueObject)   # a declaration holder
   #     price.hecks_name  = "Price"
@@ -15,17 +15,17 @@ module Hecks
     # A construct asked for an identity it cannot compute.
     class Unowned < StandardError; end
 
-    # What declares this construct; nil for a chapter, which is the top.
+    # What declares this construct; nil for a bluebook, which is the top.
     attr_accessor :hecks_owner
 
     attr_writer :hecks_name
 
-    # Marks a chapter, the only construct that legitimately has no owner.
+    # Marks a bluebook, the only construct that legitimately has no owner.
     attr_writer :hecks_root
 
     # Whether this construct is the top of its own owner chain.
     #
-    # @return [Boolean] true for a chapter, which sets `hecks_root`; false otherwise
+    # @return [Boolean] true for a bluebook, which sets `hecks_root`; false otherwise
     def hecks_root? = @hecks_root ? true : false
 
     # The name as the bluebook declares it, never the constant path.
@@ -41,9 +41,9 @@ module Hecks
     # Refuses rather than answering a bare name for an unstamped construct.
     #
     # @return [String] the fully-qualified name, joining every owner from the
-    #   chapter down to this construct
+    #   bluebook down to this construct
     # @raise [Construct::Unowned] if this construct has no owner and is not itself
-    #   a chapter (root)
+    #   a bluebook (root)
     def hecks_fqn
       return hecks_name.to_s if hecks_root?
 

data/lib/hecks/corpus/adapters.rb

@@ -13,7 +13,8 @@ module Hecks
       # @return [Array<String>] absolute paths, sorted, none under a vendored, `node_modules`,
       #   `target` or scratch directory
       def adapter_files(root: Corpus::ROOT)
-        ADAPTER_GLOBS.flat_map { |glob| Dir.glob(File.join(root, glob)) }.uniq.sort.reject do |path|
+        found = ADAPTER_GLOBS.flat_map { |glob| Dir.glob(File.join(root, glob)) }.uniq.sort
+        found.reject do |path|
           path.delete_prefix("#{root}/").split("/").intersect?(EXCLUDED_DIRS)
         end
       end

data/lib/hecks/corpus/routes.rb

@@ -15,7 +15,7 @@ module Hecks
       Route.new(%r{\Arust/}, :named_in, "rust/parser/tests/gates.rs", :each_file,
                 "the Rust parser's own fixtures, each loaded by its gate tests"),
       Route.new(%r{/translations/}, :named_in, "spec/translation/committed_edges_spec.rb", "bluebook/translations",
-                "translation edges, not chapters; each must load, chain era to era, and end at the storage " \
+                "translation edges, not bluebooks; each must load, chain era to era, and end at the storage " \
                 "shape its bluebook declares today"),
       Route.new(%r{\Alib/hecks/forms/examples/}, :named_in, "spec/forms/app_spec.rb", :each_file,
                 "a Forms presentation config wearing the .bluebook extension"),
@@ -24,9 +24,9 @@ module Hecks
                 "its filename declares (bump_* / same_*)"),
       Route.new(%r{\Aspec/fixtures/model_check/}, :named_in, "spec/model_check_spec.rb", :each_file,
                 "domains broken on purpose; each must produce exactly the finding kinds it is built to trigger"),
-      Route.new(%r{\Aspec/fixtures/site/editor_chapters/domain/}, :named_in, "spec/site_cms_editor_chapters_spec.rb",
-                "site/editor_chapters",
-                "two chapters that both declare a Category, so the editor must tell them apart; one SQLite " \
+      Route.new(%r{\Aspec/fixtures/site/editor_bluebooks/domain/}, :named_in, "spec/site_cms_editor_bluebooks_spec.rb",
+                "site/editor_bluebooks",
+                "two bluebooks that both declare a Category, so the editor must tell them apart; one SQLite " \
                 "file keeps tables by bare aggregate name, which cannot hold both, so the sweep cannot boot it"),
       # hecks fuzz sweeps it too, once Fuzzing::Replay coerces value-object args
       # before recomputing givens — today it doesn't, so this given reads as
@@ -34,8 +34,28 @@ module Hecks
       Route.new(%r{\Aspec/corpus/asks/}, :named_in, "spec/policy_ask_spec.rb", "spec/corpus/asks",
                 "a corpus-owned domain whose ports have no adapter, so an ask is refused; its frozen " \
                 "targets are held to the Ruby runtime there and to the Rust policy table in rust/codegen"),
+      Route.new(%r{\Aspec/fixtures/sentence/cms_page/sentence_form\.bluebook\z}, :named_in, "spec/sentence_form_spec.rb",
+                :each_file,
+                "a bluebook written as sentences, which only a built hecks-parse can read; the sweep boots its " \
+                "Ruby twin instead, and spec/sentence_form_spec.rb compares the pair byte for byte"),
+      Route.new(%r{\Aspec/fixtures/sentence/pizzas/}, :named_in, "spec/sentence_form_spec.rb", :each_file,
+                "Pizzas written as sentences beside its Ruby twin, whose payment policy reacts to an event " \
+                "the payment webhook emits outside this bluebook, so model_check finds it deaf; " \
+                "spec/sentence_form_spec.rb compares the pair byte for byte"),
+      Route.new(%r{\Aspec/fixtures/sentence_examples/shop/shop\.bluebook\z}, :named_in,
+                "spec/sentence_multi_word_examples_spec.rb", :each_file,
+                "a bluebook written as sentences, which only a built hecks-parse can read; the spec runs its " \
+                "examples against it, so the sweep has nothing to add"),
+      Route.new(%r{\Aspec/fixtures/sentence/orders/}, :named_in, "spec/sentence_form_spec.rb", :each_file,
+                "a bluebook written as sentences beside its Ruby twin, whose policies ask the outside and " \
+                "wait for its answers; model_check wants the hecksagon that declares that port, which the " \
+                "sweep does not load. The spec compares each pair and spec/sentence_examples_spec.rb runs " \
+                "its examples against the hecksagon"),
       Route.new(%r{\Aspec/fixtures/rust_host/}, :named_in, "rust/host/src/web/commerce.rs", "checkout_fixture",
-                "the Rust host's checkout fixture, pinned by its web and /api tests")
+                "the Rust host's checkout fixture, pinned by its web and /api tests"),
+      Route.new(%r{\Apackages/hecks-rails/spec/fixtures/}, :named_in, "packages/hecks-rails/spec/support/ledger_app.rb",
+                :each_file,
+                "the hecks-rails gem's fixture app; its own specs boot it under Rails, which this sweep cannot")
     ].freeze
   end
 end

data/lib/hecks/corpus/rust.rb

@@ -31,10 +31,25 @@ module Hecks
       's\ own\ canonical\ IR,
     /x
 
-    # The Rust-facing lists: which domains and chapters `rust/` carries, read off Cargo's
+    # 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
     # `Corpus`.
     module Rust
+      # A Cargo feature line with an empty dependency array, capturing the feature's name.
+      EMPTY_FEATURE = /^(\w+)\s*=\s*\[\]/
+
+      # Cargo's `default = ["name"]` line, capturing the default feature's name.
+      DEFAULT_FEATURE = /^default\s*=\s*\["(\w+)"\]/
+
+      # A hecksagon's `attaches "Name"` line for a gem bluebook (no `from:`), capturing the name.
+      ATTACHED_BY_NAME = /^\s*attaches\s+"(\w+)"\s*$/
+
+      # A bluebook file's `Hecks.bluebook "Name"` header, capturing the bluebook's name.
+      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
+
       # Every place a Rust-facing domain's own `attaches` attachment could be declared.
       #
       # @param root [String] repository root to search under
@@ -57,7 +72,7 @@ module Hecks
       # @param root [String] repository root to search under
       # @return [Array<String>] feature names, in file order
       def cargo_features(root: ROOT)
-        cargo_features_table(root: root).scan(/^(\w+)\s*=\s*\[\]/).flatten
+        cargo_features_table(root: root).scan(EMPTY_FEATURE).flatten
       end
 
       # The feature `hecks project_rust` last wrote as Cargo's `default`.
@@ -66,7 +81,7 @@ module Hecks
       # @return [String, nil] the default feature's name, or nil when Cargo.toml
       #   declares none
       def cargo_default(root: ROOT)
-        cargo_features_table(root: root)[/^default\s*=\s*\["(\w+)"\]/, 1]
+        cargo_features_table(root: root)[DEFAULT_FEATURE, 1]
       end
 
       # Every in-repo domain directory whose name is a Cargo feature, sorted
@@ -76,12 +91,11 @@ module Hecks
       # @return [Array<RustDomain>] each Rust-facing domain, sorted by directory path
       def rust_domains(root: ROOT)
         features = cargo_features(root: root)
-        members(*RUST_DOMAIN_KINDS, root: root)
-          .map { |member| [domain_dir_of(member), member.kind] }
-          .uniq(&:first)
-          .select { |dir, _| rust_domain_dir?(dir, features, root) }
-          .sort_by(&:first)
-          .map { |dir, kind| RustDomain.new(File.basename(dir).downcase, dir, kind) }
+        candidates = members(*RUST_DOMAIN_KINDS, root: root).map { |member| [domain_dir_of(member), member.kind] }
+                                                            .uniq(&:first)
+        candidates.select { |dir, _| rust_domain_dir?(dir, features, root) }
+                  .sort_by(&:first)
+                  .map { |dir, kind| RustDomain.new(File.basename(dir).downcase, dir, kind) }
       end
 
       # Tells whether `dir` is the real source directory for its Cargo feature.
@@ -125,14 +139,14 @@ module Hecks
         File.file?(File.join(root, GENERATED_DIR, feature, "merged.rs"))
       end
 
-      # Chapters attached via `kind` that get a generated module as a side
+      # Bluebooks attached via `kind` that get a generated module as a side
       # effect of the attaching domain's regen, with no merged.rs of their own.
       #
       # @param kind [Symbol] :framework or :vendored
       # @param root [String] repository root to search under
       # @return [Array<String>] stems with a generated module but no merged.rs
       #   of their own
-      def rust_side_chapters(kind, root: ROOT)
+      def rust_side_bluebooks(kind, root: ROOT)
         modules = generated_modules(root: root)
         members(kind, root: root).map(&:stem)
                                  .select do |stem|
@@ -150,34 +164,55 @@ module Hecks
         Naming.pascal(stem).downcase
       end
 
-      # Names the framework chapters Rust carries as modules, beside its domains' own bluebooks.
+      # Names the framework bluebooks Rust carries as modules, beside its domains' own bluebooks.
       #
       # @param root [String] repository root to search under
       # @return [Array<String>] generated module names for the `:framework` corpus members
-      def rust_framework_chapters(root: ROOT)
-        rust_side_chapters(:framework, root: root)
+      def rust_framework_bluebooks(root: ROOT)
+        rust_side_bluebooks(:framework, root: root)
       end
 
-      # Names the vendored chapters Rust carries as modules, beside its domains' own bluebooks.
+      # Names the vendored bluebooks Rust carries as modules, beside its domains' own bluebooks.
       #
       # @param root [String] repository root to search under
       # @return [Array<String>] generated module names for the `:vendored` corpus members
-      def rust_vendored_chapters(root: ROOT)
-        rust_side_chapters(:vendored, root: root)
+      def rust_vendored_bluebooks(root: ROOT)
+        rust_side_bluebooks(:vendored, root: root)
       end
 
-      # Chapters an in-repo Rust domain carries beside its own bluebook,
+      # Bluebooks an in-repo Rust domain carries beside its own bluebook,
       # written as a module by `hecks project_rust` with no merged.rs of its own.
       #
       # @param root [String] repository root to search under
       # @return [Array<String>] generated module names with no merged.rs of their own
-      def rust_sibling_chapters(root: ROOT)
+      def rust_sibling_bluebooks(root: ROOT)
         modules = generated_modules(root: root)
-        rust_domains(root: root)
-          .flat_map { |domain| Dir.glob(File.join(domain.dir, "bluebook", "*.bluebook")) }
-          .map { |path| Naming.pascal(File.basename(path, ".bluebook")).downcase }
-          .uniq
-          .select { |name| modules.include?(name) && !generated?(name, root: root) }
+        names = rust_domains(root: root)
+                .flat_map { |domain| Dir.glob(File.join(domain.dir, "bluebook", "*.bluebook")) }
+                .map { |path| Naming.pascal(File.basename(path, ".bluebook")).downcase }
+        names.uniq.select { |name| modules.include?(name) && !generated?(name, root: root) }
+      end
+
+      # Gem bluebooks outside the framework (`FrameworkBluebooks.index`, such as Bulk) that an
+      # in-repo Rust
+      # domain's hecksagon attaches by name, written as a module by `hecks project_rust` with no
+      # merged.rs of their own.
+      #
+      # @param root [String] repository root to search under
+      # @return [Array<String>] generated module names for the attached gem bluebooks
+      def rust_attached_bluebooks(root: ROOT)
+        modules = generated_modules(root: root)
+        names = rust_attachment_hecksagon_text(root: root).scan(ATTACHED_BY_NAME).flatten & gem_bluebook_names(root: root)
+        names.map { |name| Naming.pascal(name).downcase }.uniq
+             .select { |name| modules.include?(name) && !generated?(name, root: root) }
+      end
+
+      # The names the gem's own attachable bluebooks declare in their `Hecks.bluebook` headers.
+      #
+      # @param root [String] repository root to search under
+      # @return [Array<String>] bluebook names, from the files `GEM_BLUEBOOK_KINDS` hold
+      def gem_bluebook_names(root: ROOT)
+        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

data/lib/hecks/corpus/sources.rb

@@ -1,14 +1,14 @@
 module Hecks
   module Corpus
-    # How a domain's hecksagon names a chapter the gem carries and loads by name, as the QA
-    # ledger's does (`Hecks::Chapters.load!("QualityControl")`).
-    ATTACHED_CHAPTER = /Chapters\.load!\(\s*"([^"]+)"\s*\)/
+    # How a domain's hecksagon names a bluebook the gem carries and loads by name, as the QA
+    # ledger's does (`Hecks::FrameworkBluebooks.load!("QualityControl")`).
+    ATTACHED_BLUEBOOK = /FrameworkBluebooks\.load!\(\s*"([^"]+)"\s*\)/
 
     # Where a domain path keeps its bluebooks, and what a member boots. Extended onto `Corpus`.
     module Sources
       # Where a domain path keeps its bluebooks — `<domain>/bluebook/*.bluebook`, or the directory
-      # itself when that holds none, or the chapter files its hecksagons load by name (the QA
-      # ledger, `qa/bluebook`, holds only wiring: its chapter ships in
+      # itself when that holds none, or the bluebook files its hecksagons load by name (the QA
+      # ledger, `qa/bluebook`, holds only wiring: its bluebook ships in
       # `lib/hecks/quality_control/`).
       #
       # @param domain_path [String] path to a domain directory
@@ -18,17 +18,18 @@ module Hecks
           files = Dir[File.join(dir, "*.bluebook")]
           return files unless files.empty?
         end
-        attached_chapter_files(domain_path)
+        attached_bluebook_files(domain_path)
       end
 
-      # The bluebook files of every chapter a domain's own hecksagons load by name.
+      # The bluebook files of every bluebook a domain's own hecksagons load by name.
       #
       # @param domain_path [String] path to a domain directory
-      # @return [Array<String>, nil] the chapters' `.bluebook` file paths, or nil when none is named
-      def attached_chapter_files(domain_path)
+      # @return [Array<String>, nil] the bluebooks' `.bluebook` file paths, or nil when none is
+      #   named
+      def attached_bluebook_files(domain_path)
         names = Dir[File.join(domain_path, "{bluebook/,}*.hecksagon")]
-                .flat_map { |path| File.read(path).scan(ATTACHED_CHAPTER).flatten }.uniq
-        files = names.flat_map { |name| Chapters.index.fetch(name, []) }
+                .flat_map { |path| File.read(path).scan(ATTACHED_BLUEBOOK).flatten }.uniq
+        files = names.flat_map { |name| FrameworkBluebooks.index.fetch(name, []) }
         files.empty? ? nil : files
       end
 

data/lib/hecks/corpus/worlds.rb

@@ -10,7 +10,8 @@ module Hecks
       # @return [Array<String>] absolute paths, sorted, none under a vendored, `node_modules`,
       #   `target` or scratch directory
       def world_files(root: Corpus::ROOT)
-        WORLD_GLOBS.flat_map { |glob| Dir.glob(File.join(root, glob)) }.uniq.sort.reject do |path|
+        found = WORLD_GLOBS.flat_map { |glob| Dir.glob(File.join(root, glob)) }.uniq.sort
+        found.reject do |path|
           path.delete_prefix("#{root}/").split("/").intersect?(Adapters::EXCLUDED_DIRS)
         end
       end

data/lib/hecks/corpus.rb

@@ -4,6 +4,7 @@ require_relative "corpus/routes"
 require_relative "corpus/rust"
 require_relative "corpus/sources"
 require_relative "corpus/worlds"
+require_relative "sentence_form"
 
 module Hecks
   # The corpus: every place in this repo that holds a real domain, named once.
@@ -19,7 +20,7 @@ module Hecks
       example:   "examples/*",
       stress:    "qa/stress_domains/*",
       semantics: "spec/corpus/semantics/domains/*",
-      # The Hecks domain (ADR 0080): its chapters share one namespace and one hecksagon, so
+      # 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",
       # A package vendored via `attaches ... from: :vendor` — nested inside the
@@ -27,7 +28,7 @@ module Hecks
       vendored:  "examples/*/vendor/embryonaut_bluebooks/*"
     }.freeze
 
-    # **One chapter per file**. Stemmed by the path below the glob's fixed
+    # **One bluebook per file**. Stemmed by the path below the glob's fixed
     # prefix, so a nested fixture keeps its subdirectory (`eras/base`)
     # and never collides with a same-named file elsewhere in the kind.
     FILE_KINDS = {
@@ -37,9 +38,11 @@ module Hecks
       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"
     }.freeze
@@ -78,12 +81,16 @@ module Hecks
     end
 
     def directory_members(kind, root, glob)
-      Dir.glob(File.join(root, glob)).select { |path| File.directory?(path) }.sort
-         .map { |dir| Member.new(File.basename(dir), kind, dir) }
+      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[/\A[^*]*/].chomp("/"))
+      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
@@ -119,7 +126,7 @@ module Hecks
       members(*MODEL_CHECK_KINDS, root: root).reject { |member| route_for(member.path.delete_prefix("#{root}/")) }
     end
 
-    # **The ledger sweeps itself** — its own chapter is a domain like any
+    # **The ledger sweeps itself** — its own bluebook is a domain like any
     # other, and the one rotation member that is neither an example nor a
     # stress domain.
     ROTATION_LEDGER = { "quality_control" => "qa/bluebook" }.freeze
@@ -143,20 +150,22 @@ module Hecks
     # @return [Array<String>] absolute paths of every sweepable domain directory
     def sweepable_domains(root = ROOT)
       Dir.chdir(root) do
-        Dir.glob("**/*.bluebook")
-           .reject { |path| route_for(path) }
-           .map { |path| File.dirname(path) }
-           .map { |dir| File.basename(dir) == "bluebook" ? File.dirname(dir) : dir }
-           .uniq.sort
-           .map { |dir| File.join(root, dir) }
+        swept = Dir.glob("**/*.bluebook").reject { |path| route_for(path) }
+        dirs = swept.map { |path| owning_dir(File.dirname(path)) }
+        dirs.uniq.sort.map { |dir| File.join(root, dir) }
       end
     end
 
+    # 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
+
     # 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 = {
-      "lib/hecks/hecks"                                           => "the gem's own chapter; model_check covers it",
-      "spec/fixtures/qa_discover_external_domains/projects/hecks" => "declares the reserved chapter name `Hecks`"
+      "lib/hecks/hecks"                                           => "the gem's own bluebook; model_check covers it",
+      "spec/fixtures/qa_discover_external_domains/projects/hecks" => "declares the reserved bluebook name `Hecks`",
+      "spec/fixtures/sentence/cms_page"                           => "holds one bluebook twice, as sentences and as Ruby; " \
+                                                                     "sentence_form_spec compares the pair"
     }.freeze
 
     # Every sweepable domain a fuzz can boot: `sweepable_domains` less `FUZZ_UNBOOTABLE`.
@@ -174,20 +183,19 @@ module Hecks
     # @return [String] the member's owning domain directory path
     def domain_dir_of(member)
       dir = File.directory?(member.path) ? member.path : File.dirname(member.path)
-      File.basename(dir) == "bluebook" ? File.dirname(dir) : dir
+      owning_dir(dir)
     end
 
-    # The chapter a bluebook declares — `Hecks.bluebook "<Name>"` — read off
-    # the file rather than guessed from its name, since the two can differ.
+    # The bluebook a bluebook declares — `Hecks.bluebook "<Name>"`, or `Domain: <name>` for a file
+    # written as sentences — read off the file rather than guessed from its name, since the two
+    # can differ.
     #
     # @param bluebook_path [String, Array<String>] a `.bluebook` file path, or an
     #   array whose first element is used
-    # @return [String, nil] the declared chapter name, or nil when the file never
+    # @return [String, nil] the declared bluebook name, or nil when the file never
     #   declares one
-    def chapter_name_of(bluebook_path)
-      bluebook_path = Array(bluebook_path).first
-      header = File.foreach(bluebook_path).find { |line| line =~ /\A\s*Hecks\.bluebook\s+"([^"]+)"/ }
-      header && Regexp.last_match(1)
+    def bluebook_name_of(bluebook_path)
+      SentenceForm.declaration_name(Array(bluebook_path).first)
     end
   end
 end