hecks 6.0.0 → 7.0.0

data/lib/hecks/hecks/adapters/local_files.rb

@@ -3,8 +3,8 @@
 require "fileutils"
 require_relative "console_capture"
 require_relative "rails_app_files"
-require "hecks/cli/project_cli"
-require "hecks/cli/domain_stub"
+require "hecks/tools/project_cli"
+require "hecks/tools/domain_stub"
 
 module Hecks
   module Adapters
@@ -21,7 +21,7 @@ module Hecks
       def initialize(aggregate: nil, settings: {}, root: nil); end
 
       # Writes a command-line launcher beside each domain of the current directory, or beside the
-      # named ones, through `Hecks::CLI::ProjectCli`. A launcher is a generated file that only
+      # named ones, through `Hecks::Tools::ProjectCli`. A launcher is a generated file that only
       # points at its domain, so an existing one is replaced and nothing else is touched.
       #
       # @param held [Hash] the `Launch` record: `domains` (comma separated paths under the current
@@ -31,7 +31,7 @@ module Hecks
       def write(**held)
         domains = Text.comma_list(plain(held[:domains]))
         text = ConsoleCapture.answer do
-          CLI::ProjectCli.call(domains, program: "hecks project_cli", root: Dir.pwd, remove_stale_bin: false)
+          Tools::ProjectCli.call(domains, program: "hecks project_cli", root: Dir.pwd, remove_stale_bin: false)
         end
         unless text.include?("->")
           reason = text.strip.empty? ? "no domain found" : text.strip
@@ -79,7 +79,7 @@ module Hecks
       # The directory the stub is written into: the named one, or the snake-cased name under the
       # current directory.
       def stub_target(held)
-        File.expand_path(plain(held[:dir]) || CLI::DomainStub.directory(plain(held[:name])), Dir.pwd)
+        File.expand_path(plain(held[:dir]) || Tools::DomainStub.directory(plain(held[:name])), Dir.pwd)
       end
 
       # Warns that a service written inside the hecks clone is not one to deploy from there.
@@ -101,7 +101,7 @@ module Hecks
       def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
 
       def stub_files(name, adapter)
-        CLI::DomainStub.files(name: name, adapter: adapter)
+        Tools::DomainStub.files(name: name, adapter: adapter)
       rescue ArgumentError => e
         raise ConsoleCapture::Failure, e.message
       end

data/lib/hecks/hecks/adapters/process_pool.rb

@@ -43,7 +43,7 @@ module Hecks
 
       # The flags of a sweep, and the fields of the record that fill them.
       SWEEP_FLAGS = { "--seeds" => :seeds, "--steps" => :steps, "--workers" => :workers,
-                      "--adapter" => :adapter }.freeze
+                      "--adapter" => :adapter, "--shard" => :shard, "--list-shards" => :list_shards }.freeze
 
       class << self
         # @return [#call, nil] runs a child given `(command, env, chdir)` and answers a `Finished`;
@@ -60,7 +60,8 @@ module Hecks
 
       # Runs a fuzz sweep over one domain, or over every domain of the checkout when none is named.
       #
-      # @param held [Hash] the `Fuzzing` record: `domain`, `seeds`, `steps`, `workers`, `adapter`
+      # @param held [Hash] the `Fuzzing` record: `domain`, `seeds`, `steps`, `workers`, `adapter`,
+      #   `shard` and `list_shards`
       # @return [Hash{Symbol => Hash}] `report:` what the sweep printed
       # @raise [ConsoleCapture::Failure] when the sweep found something, or could not run
       def sweep(**held)

data/lib/hecks/hecks/adapters/push_size.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    # How big a push is, against the QualityControl world's `push_nudge` setting: `commits:` and
+    # `hours:` for when a push is due, and `urgent_commits:` for when it is urgent. It only says so
+    # in a line; a push of any size is never refused.
+    module PushSize
+      # The world verb that carries the thresholds.
+      VERB = "push_nudge"
+
+      # The thresholds when the world declares none.
+      DEFAULTS = { commits: 15, hours: 6, urgent_commits: 40 }.freeze
+
+      # The word a Work row's title opens with when the push is past `urgent_commits`.
+      URGENT = "URGENT"
+
+      module_function
+
+      # @param registry [Runtime::Registry, nil]
+      # @return [Hash{Symbol => Integer, Float}] `commits:`, `hours:` and `urgent_commits:`
+      def thresholds(registry)
+        declared = registry&.world("QualityControl")&.for_verb(VERB) || {}
+        merged = DEFAULTS.merge(declared.slice(*DEFAULTS.keys))
+        { commits: Integer(merged[:commits]), hours: Float(merged[:hours]),
+          urgent_commits: Integer(merged[:urgent_commits]) }
+      end
+
+      # @param ahead [Integer] the unpushed commits
+      # @param limits [Hash] see {thresholds}
+      # @return [Symbol] `:urgent`, `:over` or `:within`
+      def size_class(ahead, limits)
+        return :urgent if ahead > limits[:urgent_commits]
+
+        ahead > limits[:commits] ? :over : :within
+      end
+
+      # @return [String] the sentence past the threshold, "" within it
+      def sentence(ahead, limits)
+        kind = size_class(ahead, limits)
+        return "" if kind == :within
+
+        "#{"#{URGENT} " if kind == :urgent}PUSH NOW: #{ahead} commits is over the #{limits[:commits]} you set " \
+          "(urgent at #{limits[:urgent_commits]})"
+      end
+
+      # @return [String] the `push-due` Work row's title, naming the size class past the threshold
+      def title(base, ahead, limits)
+        case size_class(ahead, limits)
+        when :urgent then "#{URGENT}: #{base}, #{ahead} commits"
+        when :over then "#{base}, #{ahead} commits"
+        else base
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/qa_quiescing.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/qa_quiescing"
+
+Hecks.adapter "QaQuiescing" do
+  port "Quiescing"
+end

data/lib/hecks/hecks/adapters/qa_quiescing.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "console_capture"
+require "hecks/quality_control/adapters/qa_quiesce_marker"
+
+module Hecks
+  module Adapters
+    # The `Quiescing` port's adapter: writes, removes and reads the QA quiet marker
+    # (`QaQuiesceMarker`). It touches no ledger and no git state.
+    class QaQuiescing
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] `marker:` a `QaQuiesceMarker`, for a spec
+      # @param root [String, nil] unused
+      def initialize(aggregate: nil, settings: {}, root: nil)
+        @marker = settings[:marker] || QaQuiesceMarker.new
+      end
+
+      # Writes the marker.
+      #
+      # @param held [Hash] the `QaQuiesce` record: `reason`, optional `owner` and `force`
+      # @return [Hash{Symbol => Hash}] `output:` what was held
+      # @raise [ConsoleCapture::Failure] when another owner holds a fresh marker
+      def mark(**held)
+        hold = @marker.hold!(owner: owner(held), reason: plain(held[:reason]), force: plain(held[:force]) == true)
+        { output: { value: "quiesced: #{@marker.describe(hold)}" } }
+      rescue QaQuiesceMarker::Refused => e
+        raise ConsoleCapture::Failure, e.message
+      end
+
+      # Removes the marker.
+      #
+      # @param held [Hash] the `QaQuiesce` record: optional `owner` and `force`
+      # @return [Hash{Symbol => Hash}] `output:` what was released
+      # @raise [ConsoleCapture::Failure] when another owner holds a fresh marker
+      def clear(**held)
+        removed = @marker.release!(owner: owner(held), force: plain(held[:force]) == true)
+        { output: { value: removed ? "released: #{@marker.describe(removed)}" : "released: no marker was held" } }
+      rescue QaQuiesceMarker::Refused => e
+        raise ConsoleCapture::Failure, e.message
+      end
+
+      # @return [Hash{Symbol => String}] `text:` owner, reason and age of the marker
+      def status(**)
+        { text: @marker.status }
+      end
+
+      private
+
+      # The caller's name for the hold: the argument, else `HECKS_QUIESCE_OWNER`, else "unnamed".
+      def owner(held)
+        plain(held[:owner]) || ENV["HECKS_QUIESCE_OWNER"] || "unnamed"
+      end
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end

data/lib/hecks/hecks/adapters/rehearsal/inquiry.rb

@@ -20,7 +20,6 @@ module Hecks
         ALWAYS = [
           { what: "the mint itself",
             why:  "no era was written: the edge, its approval and the audit were evaluated, nothing minted" },
-          { what: "an edge's coverage of every change in the shape", why: "the mint checks it; the rehearsal does not yet" },
           { what: "commands, policies and requests", why: "no traffic was run: only the stored data and the shape were read" },
           { what: "data written after the copy was made", why: "a copy is a moment; the mint sees the data of its own" }
         ].freeze
@@ -41,8 +40,9 @@ module Hecks
         # @return [Hash] the edge facts, every refused row and its total, what was read, the parity
         #   of the two engines, and what was not checked
         def examine
-          edge = minting == "next" ? @subject.edge_from(before) : nil
+          edge = decided_edge
           refusals, after = edge ? @store.audit(@subject, edge) : [[], {}]
+          refusals = coverage_refusals(edge) + refusals
           rust = RustAudit.call(@subject, after)
           report = AuditReport.new(minting: minting, edge: edge, states: after, ruby: refusals, rust: rust)
           answer(edge, report, (refusals + rust.violations).uniq, limits(rust, report))
@@ -52,6 +52,27 @@ module Hecks
 
         def plain(value) = { value: value }
 
+        # The edge a mint would use, as the shared decision names it; nil unless it would mint.
+        def decided_edge
+          return unless minting == "next" && latest[:held_text]
+
+          verdict = resolution.verdict
+          verdict&.verdict == "would_mint" ? verdict.edge : nil
+        end
+
+        # What the mint's coverage check would refuse of the decided edge, in the same words: a
+        # change in the shape that no rule of the edge explains. The mint raises it before it
+        # writes an era.
+        def coverage_refusals(edge)
+          return [] unless edge
+
+          held = PostgresEra::LineageManager.held_bluebook(latest)
+          PostgresEra::LineageManager.check_coverage!(@subject.registry, @subject.bluebook, held, edge)
+          []
+        rescue Runtime::WiringError => e
+          [e.message]
+        end
+
         def shape
           { booted: flag(true), host_version: plain(Rehearsal.host_version), store: plain(@subject.store_kind),
             mode: plain(@subject.copy_mode), before: plain(before), after: plain(@subject.label),
@@ -91,10 +112,16 @@ module Hecks
 
         def before = latest ? latest[:label] : "none"
 
+        # Which held era the shape resolves to, by the resolution a boot records; the latest era is
+        # named as it would be minted.
+        def resolution
+          @resolution ||= @subject.resolve([*eras[0...-1], latest]) { @store.watermark(@subject) }
+        end
+
         def minting
           return "first" unless latest
 
-          before == @subject.label ? "none" : "next"
+          resolution.status == "current" ? "none" : "next"
         end
 
         def limits(rust, report)

data/lib/hecks/hecks/adapters/rehearsal/memory_store.rb

@@ -26,12 +26,29 @@ module Hecks
         # @return [void] there is nothing to drop
         def drop! = nil
 
+        # The document's eras as a lineage stores them, each with the storage shape a mint records:
+        # the document's own `projection` when it gives one, else the shape of its `held_text`,
+        # which a document holds whole, since it is written as the domain's source.
+        #
         # @param _subject [Subject] unused: the document holds its own eras
-        # @return [Array<Hash>] the eras, `ordinal` and `held_text`
+        # @return [Array<Hash>] the eras, `ordinal`, `held_text` and `projection`
         def eras(_subject)
-          Array(@document["eras"]).map { |era| { ordinal: era["ordinal"], held_text: era["held_text"] } }
+          Array(@document["eras"]).map do |era|
+            { ordinal: era["ordinal"], held_text: era["held_text"], projection: era["projection"] || shape_of(era["held_text"]) }
+          end
         end
 
+        # @return [Hash, nil] the storage shape a held text declares; nil for no text
+        def shape_of(text)
+          text && Runtime::StorageShape.project(PostgresEra::LineageManager.shadow(text))
+        end
+
+        # A document holds no ledger, so its watermark is zero and never moves.
+        #
+        # @param _subject [Subject] unused
+        # @return [Integer] the ledger watermark
+        def watermark(_subject) = 0
+
         # What the document holds: it keeps the latest state of each record only, so the head and
         # the journal counts are the same number.
         #
@@ -56,7 +73,7 @@ module Hecks
           refusals = []
           after = subject.aggregates.to_h do |aggregate|
             declared = edge.for_aggregate(aggregate.name)
-            before = records(declared&.was || aggregate.name)
+            before = split_before(edge, aggregate) || records(declared&.was || aggregate.name)
             translated = translate(aggregate, declared, before)
             refusals.concat(Translation::Audit.check(aggregate: aggregate, declared: declared, before: before,
                                                      after: translated).violations)
@@ -67,6 +84,49 @@ module Hecks
 
         private
 
+        # A split target's "before": its source's held records, fanned out one per key the split names,
+        # carrying the split's fields (ADR 0166). Nil when the aggregate is not a split target.
+        def split_before(edge, aggregate)
+          source, split = split_source_for(edge, aggregate)
+          source && fan_out(records(source.was || source.name), split)
+        end
+
+        # The source aggregate and the split that feeds `aggregate`, or nil.
+        def split_source_for(edge, aggregate)
+          edge.aggregates.each do |source|
+            split = source.splits.find { |candidate| candidate.into == aggregate.name }
+            return [source, split] if split
+          end
+          []
+        end
+
+        # One target record per source record that carries the split's key, holding the split's fields.
+        def fanned_out(held, split)
+          fields = split.fields.map(&:to_s)
+          held.filter_map do |_id, state|
+            key = split_key(state, split)
+            [key.to_s, state.slice(*fields)] if key
+          end.to_h
+        end
+
+        # A value object key is identified by its `value` member.
+        def split_key(state, split)
+          key = state[split.keyed_by.to_s]
+          key.is_a?(Hash) ? key["value"] : key
+        end
+
+        def fan_out(held, split)
+          fields = split.fields.map(&:to_s)
+          held.filter_map { |_id, state| fanned_row(state, split.keyed_by.to_s, fields) }.to_h
+        end
+
+        # One target row keyed by the held record's key, a value object's `value` member when it has one.
+        def fanned_row(state, key, fields)
+          value = state[key]
+          value = value["value"] if value.is_a?(Hash)
+          [value.to_s, state.slice(*fields)] if value
+        end
+
         def records(name) = @document.dig("records", name.to_s) || {}
 
         def translate(aggregate, declared, before)

data/lib/hecks/hecks/adapters/rehearsal/postgres_reading.rb

@@ -30,14 +30,23 @@ module Hecks
         end
 
         # @param subject [Subject] the loaded domain
-        # @param _edge [Bluebook::Translation] the edge leading to the shape
+        # @return [Integer] the ledger watermark the copy holds: zero when it holds no lineage
+        def watermark(subject)
+          return 0 unless census(subject).present
+
+          reading(subject, &:last_ordinal)
+        end
+
+        # @param subject [Subject] the loaded domain
+        # @param subject [Subject] the loaded domain
+        # @param edge [Object] the edge `Subject#decide` named for the shape, the one the mint takes
         # @return [Array(Array<String>, Hash)] what the audit's layers refuse over the stored
         #   records, and the records as translated, by aggregate name and id
-        def audit(subject, _edge)
+        def audit(subject, edge)
           return [[], {}] unless census(subject).present
 
           reading(subject) do |lineage|
-            finding = JournalStore::EdgeAudit.call(subject.held, lineage, subject.held.held_eras(lineage))
+            finding = JournalStore::EdgeAudit.call(subject.held, lineage, subject.held.held_eras(lineage), edge: edge)
             finding ? [finding.refusals, finding.after] : [[], {}]
           end
         end
@@ -53,12 +62,26 @@ module Hecks
 
         def reading(subject)
           subject.held.read_from(url)
-          db = PostgresEra.connect_for(subject.bluebook_name, subject.settings)
-          db.exec("SET default_transaction_read_only = on") if @declaration.mode == "readonly_copy"
-          yield PostgresEra::Lineage.new(db, subject.bluebook_name)
+          db = connect(subject)
+          yield PostgresEra::Lineage.new(db, subject.bluebook_name, reading: reads_only?)
         ensure
           db&.close
         end
+
+        # A copy somebody else made is opened read-only before any statement runs: the schema is
+        # selected, never created, and a digest the copy lacks is left unwritten. A database the run
+        # made is its own to touch, so it is opened as a PostgresEra boot opens it.
+        def connect(subject)
+          return PostgresEra.connect_for(subject.bluebook_name, subject.settings) unless reads_only?
+
+          require "pg"
+          PG.connect(url).tap do |db|
+            db.exec("SET default_transaction_read_only = on")
+            db.exec("SET search_path TO #{db.quote_ident(subject.settings[:schema])}") if subject.settings[:schema]
+          end
+        end
+
+        def reads_only? = @declaration.mode == "readonly_copy"
       end
     end
   end

data/lib/hecks/hecks/adapters/rehearsal/subject.rb

@@ -4,6 +4,7 @@ require_relative "declaration"
 require_relative "environment"
 require_relative "../journal_store/edge_audit"
 require_relative "../journal_store/held_domain"
+require_relative "../../../adapters/driven/postgres_era/lineage_manager/era_resolution"
 
 module Hecks
   module Adapters
@@ -113,12 +114,17 @@ module Hecks
         # @return [String] the domain's bluebook directory
         def directory = held.directory
 
-        # The edge that leads one era's label to the shape's label.
+        # Which held era the subject's shape resolves to, and the verdict a mint from the latest one
+        # would reach, by the resolution a boot records (`LineageManager::EraResolution`). It reads
+        # only the eras it is handed.
         #
-        # @param from [String] the held era's label
-        # @return [Bluebook::Translation, nil] the edge; nil when none is declared
-        def edge_from(from)
-          registry.translations.find { |t| t.domain == bluebook.name && t.from == from && t.to == label }
+        # @param eras [Array<Hash>] the copy's held eras, oldest first: `label`, `held_text`
+        # @yieldreturn [Integer] the copy's ledger watermark, read only when no held era matches
+        # @return [PostgresEra::LineageManager::EraResolution::Answer]
+        def resolve(eras, &)
+          PostgresEra::LineageManager::EraResolution.resolve(
+            eras: eras, bluebook: bluebook, translations: registry.translations, directory: directory, &
+          )
         end
 
         # @return [Array<String>] the persisted databases the domain's own world names, which a

data/lib/hecks/hecks/adapters/rust_toolchain.rb

@@ -21,7 +21,7 @@ module Hecks
       # The `Hecks::RustBuild` tool each ask runs.
       TOOLS = { generate: "project_rust", wasm: "project_wasm", host: "project_host",
                 browser_wasm: "project_wasm_browser", conform: "rust_conformance",
-                replay: "rust_conformance_fuzz", coverage: "rust_coverage" }.freeze
+                replay: "rust_conformance_fuzz", coverage: "rust_coverage", parser: "build_parser" }.freeze
 
       # The load path the benchmark child runs with: this checkout's or gem's `lib/`.
       LIB = File.expand_path("../../..", __dir__)
@@ -133,6 +133,15 @@ module Hecks
         child(:coverage, ["--check-allowlist"])
       end
 
+      # Builds the `hecks-parse` binary the parser specs run, in `rust/parser`.
+      #
+      # @param _held [Hash] the `Build` record, which holds nothing this needs
+      # @return [Hash{Symbol => Hash}] `output:` what cargo reported
+      # @raise [ConsoleCapture::Failure] when cargo cannot build the crate
+      def parser(**_held)
+        child(:parser, [])
+      end
+
       # Measures command throughput and latency for each target, building the Rust binary in the
       # workspace when it is a target and none was named. The benchmark can run for minutes, so it
       # starts through `ProcessPool`, which passes an interrupt on to it.

data/lib/hecks/hecks/adapters/rust_workspace.rb

@@ -22,7 +22,7 @@ module Hecks
       CHECKOUT_MARKER = "hecks.gemspec"
 
       # What a copy holds: the workspace manifest, the kernel and every crate a domain build uses.
-      PACKAGED = %w[Cargo.toml Cargo.lock src codegen parser
+      PACKAGED = %w[Cargo.toml Cargo.lock src codegen parser expr
                     host build web lsp].freeze
 
       # Left out of a copy: build output anywhere, the corpus tests, and the corpus domains.

data/lib/hecks/hecks/adapters/settings_reading/disposable_ledger.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class SettingsReading
+      # The `disposable ledger` row of `hecks config`: whether the copy's world declares its
+      # PostgresEra store a disposable tooling ledger, which needs no era for a shape change, and
+      # whether the world or the default says so.
+      module DisposableLedger
+        # @param directory [String] the domain directory
+        # @return [Array(String, String, String)] the row's name, value and source
+        def disposable_ledger(directory)
+          registry = Hecks.describe(directory).registry
+          declared = registry.binding_settings(registry.first_domain_name, Ports::Persistence::VERB, "PostgresEra")
+          ["disposable ledger", disposable_wording(declared), declared.key?(:disposable_ledger) ? "world" : "default"]
+        rescue StandardError => e
+          ["disposable ledger", "could not be read", first_line(e.message)]
+        end
+
+        private
+
+        def disposable_wording(declared)
+          if [true, "true"].include?(declared[:disposable_ledger])
+            "yes: a shape change needs no era, and a breaking one archives its rows"
+          else
+            "no: a shape change needs an era"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/settings_reading/push_nudge.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../../quality_control/adapters/push_due_reader"
+
+module Hecks
+  module Adapters
+    class SettingsReading
+      # The `push nudge` row of `hecks config`: how many commits or hours local main may drift ahead
+      # of origin/main before QA files the `push-due` Work row, how many commits make it urgent, and
+      # whether the QualityControl world or the default says so.
+      module PushNudge
+        # @param directory [String] the domain directory
+        # @return [Array(String, String, String)] the row's name, value and source
+        def push_nudge(directory)
+          registry = Hecks.describe(directory).registry
+          declared = registry.world("QualityControl")&.for_verb(PushDueReader::VERB)
+          limits = PushDueReader.thresholds(registry)
+          value = "#{limits[:commits]} commits or #{limits[:hours]} hours, urgent at #{limits[:urgent_commits]} commits"
+          ["push nudge", value, declared ? "world" : "default"]
+        rescue StandardError => e
+          ["push nudge", "could not be read", first_line(e.message)]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/settings_reading/stores.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class SettingsReading
+      # The store rows of `hecks config`: each loaded bluebook's store, and the aggregates whose own
+      # bind overrides it. Resolved through the runtime's binding policy, so these rows cannot
+      # disagree with a boot.
+      module Stores
+        # The adapter names the store rows recognise by their storage.
+        SQLITE = /Sqlite/
+        POSTGRES = /Postgres/
+
+        # cannot disagree with a boot.
+        def stores(directory)
+          registry = Hecks.describe(directory).registry
+          registry.bluebooks.each_value.flat_map { |declaration| store_rows(registry, declaration) }
+        rescue StandardError => e
+          [["store", "could not be read", first_line(e.message)]]
+        end
+
+        def store_rows(registry, declaration)
+          name = declaration.name
+          adapter = registry.default_adapter_for(name) || Ports::Persistence::BindingPolicy.inherited_adapter(registry,
+                                                                                                              name) || DEFAULT
+          [["store #{name}", store_of(registry, name, adapter), default_store_source(registry, name)],
+           *aggregate_store_rows(registry, declaration)]
+        end
+
+        def aggregate_store_rows(registry, declaration)
+          declaration.aggregates.filter_map do |aggregate|
+            next unless bound_here?(registry, declaration.name, aggregate)
+
+            bind = Ports::Persistence::BindingPolicy.resolve(registry, declaration.name, aggregate)
+            ["store #{declaration.name}::#{aggregate.name}", store_of(registry, declaration.name, bind.adapter),
+             "aggregate bind in the hecksagon"]
+          end
+        end
+
+        def bound_here?(registry, domain, aggregate)
+          registry.hecksagon(domain)&.binds&.any? { |bind| named?(bind, aggregate) && bind.verb == VERB } || false
+        end
+
+        # A bind names its aggregate bare or qualified by its bluebook (`Tickets::Work`), as the
+        # hecksagon wrote it.
+        def named?(bind, aggregate)
+          bind.aggregate.to_s.split("::").last == aggregate.hecks_name
+        end
+
+        def default_store_source(registry, name)
+          return "hecksagon" if registry.hecksagon(name)&.default_binds(VERB)&.any?
+          return "world default_adapter" if registry.default_adapter_for(name)
+          return "attaching domain's root default" if Ports::Persistence::BindingPolicy.inherited_adapter(registry, name)
+
+          "default"
+        end
+
+        def store_of(registry, domain, adapter)
+          settings = registry.binding_settings(domain, VERB, adapter)
+          case adapter
+          when DEFAULT then DEFAULT
+          when SQLITE then "SqliteAt #{settings[:database]}"
+          when POSTGRES then "Postgres #{database_name(settings[:database])}"
+          else adapter
+          end
+        end
+
+        # The database's name from a URL, with the password hidden and the query string left out.
+        def database_name(url)
+          without_query = hide_password(url).split("?").first.to_s
+          without_query.split("/").last.to_s
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/settings_reading/test_scope.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../codebase/test_scope"
+
+module Hecks
+  module Adapters
+    class SettingsReading
+      # The `test scope` row of `hecks config`: where the full spec suite runs and how many spec
+      # files one local call may run, and whether the Hecks world or the default says so.
+      module TestScope
+        # @param directory [String] the domain directory
+        # @return [Array(String, String, String)] the row's name, value and source
+        def test_scope(directory)
+          declared = Codebase::TestScope.setting(Hecks.describe(directory).registry)
+          return ["test scope", "no limit", "default"] if declared.empty?
+
+          ["test scope", wording(declared), "world"]
+        rescue StandardError => e
+          ["test scope", "could not be read", first_line(e.message)]
+        end
+
+        def wording(declared)
+          "full suite in #{declared[:suite_runs_in]}; at most #{declared[:spec_files_limit]} spec files per call locally"
+        end
+      end
+    end
+  end
+end