hecks 3.0.5 → 3.1.0

data/lib/hecks/cli/interview_draft.rb

@@ -0,0 +1,246 @@
+require_relative "../naming"
+require_relative "domain_stub"
+
+module Hecks
+  module CLI
+    # Turns an interview's accepted findings into the files of a first domain (ADR 0088).
+    #
+    # Pure: it answers the text of each file and writes none, so the command that runs an interview
+    # can check every target before it writes the first, and a spec can boot the result. It shares
+    # the files around a bluebook with `hecks init` (`DomainStub.support_files`) and renders the
+    # bluebook itself, from what the developer accepted, where `init` writes a fixed stub.
+    #
+    # Only `accepted` findings reach the bluebook; every finding reaches the record. A rule is never
+    # turned into code from prose: it is a comment citing its source, to become a `given` by hand.
+    module InterviewDraft
+      ACCEPTED = "accepted".freeze
+
+      # The pattern every generated string field carries: it refuses a blank value.
+      PATTERN = %q('[^ \t\n\r]').freeze
+
+      # What stands in for a creating command nothing in the interview named.
+      STUB_NOTE = "    # TODO: no action that creates was accepted; replace Create with the real one.".freeze
+      private_constant :PATTERN, :STUB_NOTE
+
+      module_function
+
+      # The files a first interview writes: the bluebook, the files around it, and the record.
+      #
+      # @param interview [Hash] the interview, with at least one accepted thing
+      # @param adapter [String, nil] an adapter in `DomainStub::ADAPTERS`; its default when nil
+      # @return [Hash{String => String}] each file's path under the domain directory, and its text
+      # @raise [ArgumentError] when nothing was accepted, or the subject or adapter is refused
+      def files(interview, adapter: nil)
+        name = interview.fetch(:subject)
+        support = DomainStub.support_files(name: name, adapter: adapter)
+        { "bluebook/#{Naming.snake(name)}.bluebook" => bluebook(interview) }
+          .merge(support)
+          .merge(record_file(interview))
+      end
+
+      # What a later interview writes: its record, ending in the aggregates and commands it would
+      # add, for a developer to merge. An existing domain is never touched (ADR 0088).
+      #
+      # @param interview [Hash] the interview
+      # @return [Hash{String => String}] the one file, `interviews/<reference>.md`
+      def additions(interview)
+        record_file(interview, "\n## Proposed additions\n\nMerge by hand into the domain's bluebook.\n\n" \
+                               "```ruby\n#{fragment(interview)}```\n")
+      end
+
+      # The interview's record: every exchange in order, and every finding with how it was decided.
+      #
+      # @param interview [Hash] the interview
+      # @return [String] Markdown
+      def record(interview)
+        lines = ["# Interview #{interview.fetch(:reference)}: #{interview.fetch(:subject)}", "",
+                 "Expert: #{interview.fetch(:expert)}", "", "## Exchanges", ""]
+        interview.fetch(:exchanges).each_with_index { |ex, i| lines.concat(exchange_lines(ex, i + 1)) }
+        lines << "" << "## Findings" << ""
+        lines.concat(finding_lines(interview))
+        "#{lines.join("\n")}\n"
+      end
+
+      # Reads the plain interview out of an `Interview` record booted from the SME chapter.
+      #
+      # @param interview [Object] the booted record
+      # @return [Hash] the plain interview this module takes: `reference`, `subject`, `expert`,
+      #   `exchanges` (`question`, `answer`, `topic`), and `things`, `actions` and `rules`, each a
+      #   finding with its `number`, `source` and `status` and the fields of its kind
+      def from_record(interview)
+        { reference: plain(interview.reference), subject: plain(interview.subject), expert: plain(interview.expert),
+          exchanges: interview.exchanges.map { |ex| slice(ex, :question, :answer, :topic) },
+          things:    interview.thing_findings.map { |f| slice(f, :number, :name, :identifier, :source, :status) },
+          actions:   interview.action_findings.map { |f| slice(f, :number, :name, :thing, :event, :creates, :source, :status) },
+          rules:     interview.rule_findings.map { |f| slice(f, :number, :statement, :source, :status) } }
+      end
+
+      # @api private
+      def record_file(interview, tail = "")
+        { "interviews/#{file_stem(interview.fetch(:reference))}.md" => record(interview) + tail }
+      end
+
+      # @api private
+      def file_stem(reference) = reference.to_s.gsub(/[^A-Za-z0-9._-]/, "_")
+
+      # @api private
+      def bluebook(interview)
+        name = interview.fetch(:subject)
+        things = accepted(interview, :things)
+        raise ArgumentError, "nothing was accepted: a draft needs at least one thing" if things.empty?
+
+        out = ["Hecks.bluebook #{name.inspect} do"]
+        out.concat(header(interview))
+        out << %(  vision "TODO: say in one sentence what #{name} is for.")
+        out << "  supporting" << ""
+        out.concat(rule_lines(interview))
+        out << fragment(interview).chomp << "end"
+        "#{out.join("\n")}\n"
+      end
+
+      # The aggregates, with their commands: the part a later interview offers to merge.
+      # @api private
+      def fragment(interview)
+        things = accepted(interview, :things)
+        actions = accepted(interview, :actions)
+        placed = things.map { |t| word(t[:name]) }
+        blocks = things.map { |thing| aggregate(interview, thing, actions) }
+        loose = actions.reject { |a| placed.include?(word(a[:thing])) }
+        blocks << unplaced(interview, loose) unless loose.empty?
+        "#{blocks.join("\n\n")}\n"
+      end
+
+      # @api private
+      def header(interview)
+        ["  # Drafted from interview #{interview[:reference]} with #{interview[:expert]}. Each name below cites the",
+         "  # exchange it came from; edit freely."]
+      end
+
+      # @api private
+      def rule_lines(interview)
+        rules = accepted(interview, :rules)
+        return [] if rules.empty?
+
+        ["  # RULES the expert gave, for you to turn into `given` clauses:"] +
+          rules.map { |r| "  #   - #{cite(interview, r)} #{one_line(r[:statement])}" } + [""]
+      end
+
+      # @api private
+      def aggregate(interview, thing, actions)
+        name = word(thing[:name])
+        field = Naming.snake(word(thing[:identifier]))
+        field_type = identifier_type(name, field)
+        mine = actions.select { |a| word(a[:thing]) == name }
+        creating = mine.select { |a| a[:creates] }
+        rest = mine - creating
+        lines = ["  # #{source_note(interview, thing)}".rstrip,
+                 "  aggregate #{name.inspect} do",
+                 "    description #{"TODO: describe what a #{name} is.".inspect}", "",
+                 "    identified_by :#{field}", "",
+                 "    attribute :#{field}, #{field_type}", "",
+                 "    value_object #{field_type.inspect} do",
+                 "      attribute :value, String, pattern: #{PATTERN}",
+                 "    end"]
+        creating = [stub_create(name)] if creating.empty?
+        creating.each { |action| lines.concat(creating_command(interview, action, field, field_type)) }
+        rest.each { |action| lines.concat(mutating_command(interview, action, name)) }
+        (lines << "  end").join("\n")
+      end
+
+      # The creating command nothing in the interview named: a stub, marked for the developer.
+      # @api private
+      def stub_create(name) = { name: "Create", event: "#{name}Created", stub: true }
+
+      # @api private
+      def creating_command(interview, action, field, field_type)
+        verb = word(action[:name])
+        note = action[:stub] ? STUB_NOTE : "    # #{source_note(interview, action)}"
+        ["", note, "    command #{verb.inspect} do", "      goal #{"TODO: say what #{verb} does".inspect}", "",
+         "      attribute :#{field}, #{field_type}", "", "      emits #{word(action[:event]).inspect}", "    end"]
+      end
+
+      # @api private
+      def mutating_command(interview, action, name)
+        verb = word(action[:name])
+        ["", "    # #{source_note(interview, action)}", "    command #{verb.inspect} do",
+         "      goal #{"TODO: say what #{verb} does".inspect}", "", "      reference_to #{name}", "",
+         "      emits #{word(action[:event]).inspect}", "    end"]
+      end
+
+      # An action whose thing nobody accepted has nowhere to go; it is kept as a comment, not lost.
+      # @api private
+      def unplaced(interview, actions)
+        lines = ["  # UNPLACED: these accepted actions name a thing that was not accepted. Place each, or drop it."]
+        actions.each do |action|
+          lines << "  #   - #{cite(interview, action)} #{word(action[:name])} on #{action[:thing]}, announcing #{action[:event]}"
+        end
+        lines.join("\n")
+      end
+
+      # @api private
+      def identifier_type(name, field)
+        type = Naming.pascal(field)
+        type == name ? "#{type}Id" : type
+      end
+
+      # @api private
+      def exchange_lines(exchange, number)
+        lines = ["#{number}. **Q:** #{one_line(exchange[:question])}", "   **A:** #{one_line(exchange[:answer])}"]
+        topic = exchange[:topic].to_s
+        lines << "   _Topic: #{one_line(topic)}_" unless topic.empty?
+        lines
+      end
+
+      # @api private
+      def finding_lines(interview)
+        lines = interview.fetch(:things).map do |f|
+          "- Thing #{f[:number]}, #{f[:status]}: **#{f[:name]}**, identified by `#{f[:identifier]}` (exchange #{f[:source]})"
+        end
+        lines += interview.fetch(:actions).map do |f|
+          creates = f[:creates] ? ", creates it" : ""
+          "- Action #{f[:number]}, #{f[:status]}: **#{f[:name]}** on #{f[:thing]}, " \
+            "announcing `#{f[:event]}`#{creates} (exchange #{f[:source]})"
+        end
+        lines + interview.fetch(:rules).map do |f|
+          "- Rule #{f[:number]}, #{f[:status]}: #{one_line(f[:statement])} (exchange #{f[:source]})"
+        end
+      end
+
+      # @api private
+      def accepted(interview, kind) = interview.fetch(kind).select { |finding| finding[:status] == ACCEPTED }
+
+      # A free-text name as a PascalCase word safe to write into Ruby: `lend a book` is `LendABook`.
+      # @api private
+      def word(text) = text.to_s.split(/[^A-Za-z0-9]+/).reject(&:empty?).map { |part| part.sub(/\A./, &:upcase) }.join
+
+      # @api private
+      def one_line(text) = text.to_s.gsub(/\s+/, " ").strip
+
+      # @api private
+      def cite(interview, finding) = "#{interview[:reference]} ##{finding[:source]}:"
+
+      # Where a name came from: the interview, the exchange, and a short quotation of the answer.
+      # @api private
+      def source_note(interview, finding)
+        exchange = interview.fetch(:exchanges)[finding[:source].to_i - 1]
+        note = "from #{cite(interview, finding)}"
+        return note unless exchange
+
+        text = one_line(exchange[:answer])
+        text = "#{text[0, 77]}..." if text.length > 80
+        "#{note} #{text.inspect}"
+      end
+
+      # @api private
+      def plain(value)
+        return nil if value.nil?
+
+        found = value.respond_to?(:to_h) && !value.is_a?(String) ? value.to_h : value
+        found.is_a?(Hash) && found.key?(:value) ? found[:value] : found
+      end
+
+      # @api private
+      def slice(record, *keys) = keys.to_h { |key| [key, plain(record[key])] }
+    end
+  end
+end

data/lib/hecks/cli/model_check.rb

@@ -88,7 +88,7 @@ module Hecks
       end
 
       # `root:` is the source's parent, so a member declaring
-      # `uses_embryonaut_bluebook` can vendor from it.
+      # `attaches ... from: :vendor` can vendor from it.
       def boot(source)
         root = File.directory?(source) ? File.dirname(source) : nil
         registry = Runtime::Registry.new(root: root)

data/lib/hecks/cli/project_cli.rb

@@ -17,7 +17,7 @@ module Hecks
       # Build output and other trees under a root that hold no domain a caller means.
       IGNORED = %r{\A(rust|deploy|tmp|coverage)/}
 
-      # What a chapter name, a domain path and a launcher verb may be made of.
+      # What a chapter name, a domain path and a launcher command may be made of.
       NAME = /\A[A-Za-z][A-Za-z0-9_ ]*\z/
       PATH = %r{\A[\w./-]+\z}
       VERB = /\A[A-Za-z_][A-Za-z0-9_]*\z/
@@ -40,9 +40,28 @@ module Hecks
         status.zero? ? puts(text) : abort(text)
       LAUNCHER_TAIL
 
+      # What a Memory command does when refused: say why, from the record's `refusal`.
+      MEMORY_REFUSAL = <<~'LAUNCHER_REFUSAL'.gsub(/^/, "  ").freeze
+        if MEMORY_COMMANDS.include?(ARGV.first.to_s.chomp("!"))
+          why = begin
+            require "json"
+            JSON.parse(text).dig("state", "refusal", "value")
+          rescue JSON::ParserError
+            nil
+          end
+          warn(why ? why.sub(/\A(\w+::)+\w+: /, "") : reason)
+        else
+          puts text
+          warn reason
+        end
+      LAUNCHER_REFUSAL
+
       # The generator's name as an executable launcher's header states it, whoever ran it.
       GENERATOR = "hecks project_cli".freeze
 
+      # The launcher's test for a Memory command; a trailing `!` is not part of the name.
+      RUNS_ON_MEMORY = 'MEMORY_COMMANDS.include?(ARGV.first.to_s.chomp("!"))'.freeze
+
       module_function
 
       # Writes a launcher for each named domain, or for every domain under `root`.
@@ -103,7 +122,7 @@ module Hecks
         label      = executable || "#{path}/#{snake}"
         file       = File.join(root, label)
         text       = launcher(path, name, program, executable: executable, legacy: setting[:legacy],
-                          memory_verbs: setting[:memory_verbs], opted: !setting.empty?)
+                          memory_commands: setting[:memory_commands], opted: !setting.empty?)
         return skip(path, "#{label} is a directory") if File.directory?(file)
 
         return :drifted if check && !(File.file?(file) && File.read(file) == text)
@@ -149,12 +168,12 @@ module Hecks
       # @param program [String] the generator's invocation, named in the header
       # @param executable [String, nil] the file's path under the root when it is not beside the
       #   domain; its program name is then that file's basename, and its header names the generator
-      # @param legacy [Array<String>, nil] verbs an executable hands to `Hecks::CLI` first
-      # @param memory_verbs [Array<String>, nil] verbs run on Memory unless HECKS_ENVIRONMENT is set
+      # @param legacy [Array<String>, nil] commands an executable hands to `Hecks::CLI` first
+      # @param memory_commands [Array<String>, nil] commands that default to Memory
       # @param opted [Boolean] whether the chapter's world declares a `launcher` setting
       # @return [String] the Ruby source
-      # @raise [ArgumentError] if a name, path, executable or legacy verb is not plain
-      def launcher(path, name, program, executable: nil, legacy: nil, memory_verbs: nil, opted: !executable.nil?)
+      # @raise [ArgumentError] if a name, path, executable or legacy command is not plain
+      def launcher(path, name, program, executable: nil, legacy: nil, memory_commands: nil, opted: !executable.nil?)
         plain!("chapter name", name, NAME)
         plain!("domain path", path, PATH)
         snake = Naming.snake(name)
@@ -175,35 +194,35 @@ module Hecks
           where = shown = "#{path}/#{snake}"
         end
 
-        handoff  = legacy_handoff(Array(legacy)) + memory_default(Array(memory_verbs)) if executable
+        handoff  = legacy_handoff(Array(legacy)) + memory_default(Array(memory_commands)) if executable
         encoding = opted ? ENCODING : ""
         ending   = opted ? OPTED_ENDING : PLAIN_ENDING
-        ending   = quiet_ending(ending) if executable && !Array(memory_verbs).empty?
+        ending   = quiet_ending(ending) if executable && !Array(memory_commands).empty?
 
         <<~RUBY
           #!/usr/bin/env ruby
 
           # #{name}'s command line — GENERATED by #{program}. Do not edit.
           #
-          # A launcher, not a CLI: the verbs, their arguments and their refusals are
+          # A launcher, not a CLI: the commands, their arguments and their refusals are
           # projected from the bluebook beside it every time this runs, so a change
           # to the chapter shows up here without re-minting anything.
           #
-          #   #{where}                  every verb, and every question
-          #   #{where} <verb> --help    what it wants, and how it refuses
+          #   #{where}                  every command, and every question
+          #   #{where} <command> --help    what it wants, and how it refuses
 
           #{encoding}$LOAD_PATH.unshift File.expand_path("#{up}lib", __dir__)
           #{handoff}
           require "hecks"
 
-          #{entry(name, boot, shown, opted, quiet: !Array(memory_verbs).empty?)}
+          #{entry(name, boot, shown, opted, quiet: !Array(memory_commands).empty?)}
           #{ending}
         RUBY
       end
 
       # @api private
       # @return [String] the launcher's middle: for an opted-in launcher, usage answered from the
-      #   projection and a boot only for a line that runs a verb; for any other, the boot and
+      #   projection and a boot only for a line that runs a command; for any other, the boot and
       #   dispatch every launcher has always had, byte for byte
       def entry(name, boot, shown, opted, quiet: false)
         opted ? described_entry(name, boot, shown, quiet: quiet) : plain_entry(name, boot, shown)
@@ -213,10 +232,10 @@ module Hecks
       # @return [String] the opted-in launcher's middle
       def described_entry(name, boot, shown, quiet: false)
         started = "Hecks.boot_described(described, install_doors: false)"
-        started = "Hecks::Doors::LauncherOptions.quietly(hold: MEMORY_VERBS.include?(ARGV.first)) { #{started} }" if quiet
+        started = "Hecks::Doors::LauncherOptions.quietly(hold: #{RUNS_ON_MEMORY}) { #{started} }" if quiet
         <<~RUBY.chomp
           # Usage is answered from the projected chapter alone: no adapter is bound and no
-          # database is opened. Only a line that runs a verb boots the domain,
+          # database is opened. Only a line that runs a command boots the domain,
           # and it boots from what the usage check already loaded.
           domain = #{boot}
           program = "#{shown}"
@@ -270,35 +289,38 @@ module Hecks
 
       # @api private
       # @param ending [String] the launcher's closing lines
-      # @return [String] the same lines, except that a memory verb that ended well prints nothing: a
-      #   person is at it, so the settled record is noise after the session
+      # @return [String] the same lines, except that a memory command prints no settled record, only
+      #   the reason it was refused: a person is at it, so the record is noise
       def quiet_ending(ending)
-        ending.sub("status.zero? ? puts(text)",
-                   "exit 0 if status.zero? && MEMORY_VERBS.include?(ARGV.first)\nstatus.zero? ? puts(text)")
+        ending.sub("  puts text\n  warn reason\n", MEMORY_REFUSAL)
+              .sub("status.zero? ? puts(text)",
+                   "exit 0 if status.zero? && MEMORY_COMMANDS.include?(ARGV.first.to_s.chomp(\"!\"))\nstatus.zero? ? puts(text)")
       end
 
       # @api private
-      # @return [String] the lines that default the listed verbs to Memory, or nothing
-      def memory_default(verbs)
-        return "" if verbs.empty?
+      # @return [String] the lines that default the listed commands to Memory, or nothing
+      def memory_default(commands)
+        return "" if commands.empty?
 
-        verbs.each { |verb| plain!("memory verb", verb, VERB) }
+        commands.each { |command| plain!("memory command", command, VERB) }
 
         <<~RUBY
 
-          # These verbs keep nothing worth a database, so they run on Memory unless told otherwise, and
-          # print nothing when they end well.
-          MEMORY_VERBS = %w[#{verbs.join(' ')}].freeze
-          ENV["HECKS_ENVIRONMENT"] ||= "memory" if MEMORY_VERBS.include?(ARGV.first)
+          # These commands keep nothing worth a database, so they run on Memory unless told otherwise.
+          # A person is at them: they wait for their result, say why when they are refused, and print
+          # no record when they end well.
+          MEMORY_COMMANDS = %w[#{commands.join(' ')}].freeze
+          ENV["HECKS_ENVIRONMENT"] ||= "memory" if MEMORY_COMMANDS.include?(ARGV.first.to_s.chomp("!"))
+          ARGV << "--wait" if MEMORY_COMMANDS.include?(ARGV.first.to_s.chomp("!")) && !ARGV.include?("--wait")
         RUBY
       end
 
       # @api private
-      # @return [String] the lines that hand the legacy verbs to `Hecks::CLI`, or nothing
+      # @return [String] the lines that hand the legacy commands to `Hecks::CLI`, or nothing
       def legacy_handoff(legacy)
         return "" if legacy.empty?
 
-        legacy.each { |verb| plain!("legacy verb", verb, VERB) }
+        legacy.each { |command| plain!("legacy command", command, VERB) }
 
         <<~RUBY
 

data/lib/hecks/cli/reference.rb

@@ -5,7 +5,8 @@ require_relative "../projection_files"
 
 module Hecks
   module CLI
-    # The command behind `hecks project_reference`: regenerates `docs/implemented/reference/` from
+    # The command behind `hecks language_run.project_reference`: regenerates
+    # `docs/implemented/reference/` from
     # the language's Syntax chapter. Tables come from the declaration; prose is kept from the
     # committed pages.
     module Reference

data/lib/hecks/cli/refresh_rspec_runtime_baseline.rb

@@ -39,7 +39,7 @@ module Hecks
         if argv.first == "--from-run"
           from_run(root, argv.fetch(1) { abort USAGE }, out)
         else
-          from_local(root, argv.fetch(0, "6"), out)
+          from_local(root, argv.fetch(0) { abort USAGE }, out)
         end
         0
       end

data/lib/hecks/cli/seed_semantics_corpus.rb

@@ -6,15 +6,15 @@ require_relative "../fuzzing"
 
 module Hecks
   module CLI
-    # The command behind `hecks seed_semantics_corpus`: seeds (or deliberately re-seeds) the
+    # The command behind `hecks test_suite_run.seed_semantics_corpus`: seeds (or re-seeds) the
     # `expect` block of corpus fixtures from the Ruby runtime. Review the result
     # against `docs/semantics/bluebook-semantics.md` before committing.
     #
     # Seeds `spec/corpus/semantics/` and the conformance corpus ({FULL_SCRIPTS} plus
     # `spec/corpus/rust_conformance/`, whose `expect` also freezes more).
     #
-    #   hecks seed_semantics_corpus                                # fill fixtures missing an expect
-    #   SEED=refusal_kind_lifecycle hecks seed_semantics_corpus    # re-seed one, deliberately
+    #   hecks test_suite_run.seed_semantics_corpus   # fill what lacks an expect
+    #   SEED=refusal_kind_lifecycle hecks test_suite_run.seed_semantics_corpus   # re-seed one
     #
     # The seeded expectation is the definition, not a recording: both runtimes are compared to it.
     # `occurred_at` is stripped from events (C7.3/C9.1); refusals keep verb, error and kind (C8.2).

data/lib/hecks/cli/spec_example.rb

@@ -5,7 +5,7 @@ require "rspec/core"
 module Hecks
   module CLI
     # The command behind `hecks run_spec_example`: runs one spec file filtered to one example
-    # through `RSpec::Core::Runner`, so a `hecks quality_control log --demonstration` string
+    # through `RSpec::Core::Runner`, so a `hecks quality_control bug.log --demonstration` string
     # needs no `-e` quoting.
     module SpecExample
       USAGE = "usage: hecks run_spec_example <spec_file> <example description substring>"

data/lib/hecks/cli/stress_concurrency_specs.rb

@@ -31,9 +31,8 @@ module Hecks
       USAGE = <<~TEXT
         Usage: hecks stress_concurrency [--runs N] [--parallel N] [--seed-start N]
 
-          --runs N        How many times to run EACH group below (default 30).
-                           Each run uses a different --seed (seed-start + run
-                           index).
+          --runs N        How many times to run EACH group below. Each run uses
+                           a different --seed (seed-start + run index).
           --parallel N    How many parallel-safe-group runs to have going as
                            separate OS processes AT THE SAME TIME (default: this
                            machine's own core count, via Etc.nprocessors) — real
@@ -41,9 +40,12 @@ module Hecks
                            seeds one after another. The Postgres-backed group
                            always runs one process at a time regardless of this
                            flag.
-          --seed-start N  First --seed value (default 1); runs use seed_start,
+          --seed-start N  First --seed value; runs use seed_start,
                            seed_start + 1, ... seed_start + runs - 1.
 
+        `hecks stress_concurrency` fills --runs and --seed-start from the defaults its
+        bluebook declares (`hecks stress_concurrency --help` shows them).
+
         Exits 0 if every run's every example passed, 1 if anything failed -
         failing runs' full output is saved under tmp/stress-failures/
         for a real repro (same seed, same command, just add CI=true).
@@ -60,10 +62,17 @@ module Hecks
       #   unknown argument
       def call(argv, root:, out: $stdout)
         argv = argv.dup
-        settings = { runs: 30, parallel: Etc.nprocessors, seed_start: 1 }
+        settings = { parallel: Etc.nprocessors }
         status = parse!(argv, settings, out)
         return status if status
 
+        missing = %i[runs seed_start].reject { |name| settings.key?(name) }
+        unless missing.empty?
+          warn "missing #{missing.map { |name| "--#{name.to_s.tr('_', '-')}" }.join(', ')}: " \
+               "`hecks stress_concurrency` supplies the defaults its bluebook declares (--help for usage)"
+          return 64
+        end
+
         results = run_all(root, settings, out)
         report(root, results, out)
       end

data/lib/hecks/corpus.rb

@@ -17,7 +17,7 @@ module Hecks
       # The Hecks domain (ADR 0080): its chapters 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 `uses_embryonaut_bluebook` — nested inside the
+      # 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/*"
     }.freeze
@@ -31,7 +31,9 @@ module Hecks
       qa:        "lib/hecks/quality_control/*.bluebook",
       language:  "lib/hecks/language/**/*.bluebook",
       deploy:    "lib/hecks/deploy/bluebook/*.bluebook",
+      site:      "lib/hecks/site/bluebook/*.bluebook",
       tenancy:   "lib/hecks/tenancy/bluebook/*.bluebook",
+      sme:       "lib/hecks/sme/bluebook/*.bluebook",
       fixture:   "spec/fixtures/**/*.bluebook"
     }.freeze
 
@@ -232,14 +234,14 @@ module Hecks
     Elsewhere = Struct.new(:check, :destination, :names, :why)
 
     RUST_ELSEWHERE = {
-      "meta" => Elsewhere.new(:named_in, "spec/codegen_parity_spec.rb", "bluebook_language",
+      "meta" => Elsewhere.new(:named_in, "lib/hecks/tools/regeneration_run.rb", "rust/src/generated",
                               "the self-hosted grammar (lib/hecks/language), not a domain directory — every " \
-                              "hecks project_rust run rewrites it (so the drift check diffs it), codegen parity " \
-                              "checks it as bluebook_language, and there is no directory to fuzz")
+                              "hecks project_rust run rewrites it, so the drift check diffs it with the rest " \
+                              "of rust/src/generated, and there is no directory to fuzz")
     }.freeze
 
-    # Every place a Rust-facing domain's own `uses_framework`/
-    # `uses_embryonaut_bluebook` attachment could be declared.
+    # Every place a Rust-facing domain's own `attaches` (or the deprecated `uses_framework` /
+    # `uses_embryonaut_bluebook`) attachment could be declared.
     #
     # @param root [String] repository root to search under
     # @return [String] every reachable hecksagon file's own text, joined by newlines
@@ -307,10 +309,11 @@ module Hecks
 
     # The stamp hecks project_rust writes into metadata.rs, e.g.
     # `examples/pizzas` or `the self-hosted language (...)`, with any
-    # ` (uses_framework "X")`/` (uses_embryonaut_bluebook "X")` suffix stripped.
+    # ` (attaches "X")`/` (attaches "x", from: :vendor)` suffix stripped (the deprecated
+    # `uses_framework` / `uses_embryonaut_bluebook` spellings too).
     SOURCE_STAMP = /
       GENERATED\ by\ hecks\ project_rust\ —\ (.+?)
-      (?:\ \((?:uses_framework|uses_embryonaut_bluebook)\ "\w+"\))?
+      (?:\ \((?:attaches|uses_framework|uses_embryonaut_bluebook)\ "\w+"(?:,\ from:\ :vendor)?\))?
       's\ own\ canonical\ IR,
     /x