hecks 3.0.5 → 3.1.1

data/lib/hecks/cli/interview_session.rb

@@ -0,0 +1,299 @@
+require_relative "interview_draft"
+
+module Hecks
+  module CLI
+    # One interview, held at a terminal (ADR 0088).
+    #
+    # hecks drives: it asks the agent for a question, shows it, reads the answer the developer typed
+    # back from the expert, records it, asks the agent what the answer names as findings, and puts
+    # each to the developer to accept or reject. The agent never dispatches anything. Every SME
+    # command is dispatched here, so the domain's own rules are the guard on the interview.
+    #
+    # With no agent (`--no-ai`), or for a turn the agent could not answer, a plain prompt stands in:
+    # a fixed question, and findings typed by the developer.
+    class InterviewSession
+      NOTICE = "Your answers are sent to a model through your own `claude` login. " \
+               "Run with --no-ai to leave it out.".freeze
+
+      FALLBACK_QUESTIONS = [
+        "What is the main thing this business keeps track of?",
+        "What happens to it, from the beginning to the end?",
+        "What must never happen?",
+        "Is there anything else I should know?"
+      ].freeze
+
+      TASK = "You interview a subject matter expert, through the developer who sits beside them, about the " \
+             "business domain called %<subject>s, so the developer can model it. Ask one plain-language " \
+             "question at a time about what the business keeps track of, what happens to it, and what must " \
+             "never happen. Use the expert's own words. Do not assume what kind of business it is, or an " \
+             "industry, from the name of the domain: learn it from what the expert says. When you interpret " \
+             "an answer, propose findings only with the verbs listed under `verbs`, using the argument " \
+             "names given there, and nothing else.".freeze
+
+      VERBS = {
+        "SME::Interview.ProposeThing"  => {
+          "meaning"   => "a thing the business keeps track of, and the field that identifies one of it",
+          "arguments" => %w[name identifier]
+        },
+        "SME::Interview.ProposeAction" => {
+          "meaning"   => "something that happens to a thing, and the event it announces, in the past tense",
+          "arguments" => %w[name thing event creates]
+        },
+        "SME::Interview.ProposeRule"   => {
+          "meaning"   => "a rule the expert stated, in their own words",
+          "arguments" => %w[statement]
+        }
+      }.freeze
+
+      # What each finding verb needs, and the SME commands that carry it out and decide it.
+      KINDS = {
+        "SME::Interview.ProposeThing"  => { kind: "thing", fields: %w[name identifier], propose: :propose_thing!,
+                                           entity: "ThingFinding", accept: "AcceptThing", reject: "RejectThing" },
+        "SME::Interview.ProposeAction" => { kind: "action", fields: %w[name thing event creates],
+                                            propose: :propose_action!, entity: "ActionFinding",
+                                            accept: "AcceptAction", reject: "RejectAction" },
+        "SME::Interview.ProposeRule"   => { kind: "rule", fields: %w[statement], propose: :propose_rule!,
+                                          entity: "RuleFinding", accept: "AcceptRule", reject: "RejectRule" }
+      }.freeze
+
+      TRUE_WORDS = %w[true yes y 1].freeze
+
+      Result = Struct.new(:status, :interview, keyword_init: true)
+
+      # @param runtime [Runtime] the booted SME chapter
+      # @param agent [#question, #proposals, nil] the interviewer; nil runs the plain prompts
+      # @param input [#gets] where the developer types
+      # @param output [#puts, #print] where the session speaks
+      # @param reference [String] the interview's reference, such as `INT-1`
+      # @param subject [String] the domain being discovered, as its bluebook will spell it
+      # @param expert [String] who is being interviewed
+      def initialize(runtime:, agent:, input:, output:, reference:, subject:, expert:)
+        @runtime = runtime
+        @agent = agent
+        @input = input
+        @output = output
+        @reference = reference
+        @subject = subject
+        @expert = expert
+        @asked = []
+        @number = 0
+        @suggested = false
+      end
+
+      # Holds the interview until the developer finishes or quits.
+      #
+      # @return [Result] `concluded` with the plain interview (see `InterviewDraft`), or `cancelled`
+      def call
+        ::Interview.plan!(reference: @reference, subject: @subject, expert: @expert).begin!
+        say("#{NOTICE}\n") if @agent
+        say("Type done when there is enough to start, or quit to stop and write nothing.\n")
+        turn until finished?
+        outcome
+      end
+
+      private
+
+      def outcome
+        return Result.new(status: :cancelled) if @cancelled
+
+        Result.new(status: :concluded, interview: InterviewDraft.from_record(current))
+      end
+
+      def finished? = @finished
+
+      def current = ::Interview.find(@reference)
+
+      def turn
+        question = next_question
+        say("\n#{question}")
+        answer = ask("> ")
+        return end_of_input if answer.nil?
+
+        case answer.strip.downcase
+        when "" then say("Say what the expert said, or type done.")
+        when "done" then conclude
+        when "quit" then cancel
+        else answered(question, answer.strip)
+        end
+      end
+
+      def answered(question, answer)
+        current.record!(question: question, answer: answer)
+        @asked << question
+        findings_from(answer)
+        suggest_enough
+      end
+
+      def next_question
+        asked = @asked.dup
+        proposed = @agent && ask_agent { @agent.question(state: state, asked: asked) }
+        text = proposed&.text
+        return text if text && !@asked.include?(text)
+
+        FALLBACK_QUESTIONS.find { |q| !@asked.include?(q) } || FALLBACK_QUESTIONS.last
+      end
+
+      def findings_from(answer)
+        proposals = @agent && ask_agent { @agent.proposals(prose: answer, state: state) }
+        return manual_findings unless proposals
+
+        proposals.each { |proposal| review(proposal) }
+      end
+
+      # Runs one call to the agent; a turn it cannot answer is said aloud, and a plain one follows.
+      def ask_agent
+        yield
+      rescue Ports::Agent::Unavailable, Ports::Agent::ValidationError => e
+        say("The AI could not answer (#{e.message.lines.first.to_s.strip}). Using a plain prompt for this turn.")
+        nil
+      end
+
+      def review(proposal)
+        config = KINDS[proposal.verb]
+        return say("Ignored a proposal for #{proposal.verb}: not a finding I know.") unless config
+
+        fields = fields_of(proposal, config)
+        missing = config[:fields].reject { |f| f == "creates" || fields[f].to_s.strip != "" }
+        return say("Ignored a #{config[:kind]} proposal with no #{missing.join(', ')}.") unless missing.empty?
+
+        number = propose(config, fields) or return
+        say("  Proposed #{describe(config, fields)}")
+        say("  because: #{proposal.rationale}")
+        decide(config, number, accept?("  Accept? [Y/n] "))
+      end
+
+      def fields_of(proposal, config)
+        rows = proposal.arguments.to_h { |row| [row[:name].to_s, row[:value]] }
+        fields = rows.slice(*config[:fields])
+        fields["creates"] = TRUE_WORDS.include?(fields["creates"].to_s.downcase) if fields.key?("creates")
+        fields
+      end
+
+      def propose(config, fields)
+        number = (@number += 1)
+        args = fields.transform_keys(&:to_sym).merge(number: number, source: current.exchanges.size)
+        current.public_send(config[:propose], **args)
+        number
+      rescue StandardError => e
+        say("  Could not keep that finding: #{reason(e)}")
+        nil
+      end
+
+      def decide(config, number, accepted)
+        verb = accepted ? config[:accept] : config[:reject]
+        @runtime.dispatch_flat("SME::Interview.#{config[:entity]}.#{verb}",
+                               reference: { value: @reference }, number: { value: number })
+        say(accepted ? "  Accepted." : "  Rejected.")
+      rescue StandardError => e
+        say("  Could not record the decision: #{reason(e)}")
+      end
+
+      def describe(config, fields)
+        case config[:kind]
+        when "thing" then "thing: #{fields['name']}, identified by #{fields['identifier']}"
+        when "action" then "action: #{fields['name']} on #{fields['thing']}, announcing #{fields['event']}" \
+                           "#{', creating it' if fields['creates']}"
+        else "rule: #{fields['statement']}"
+        end
+      end
+
+      # The plain prompt: findings typed by the developer, accepted as they are entered.
+      def manual_findings
+        loop do
+          kind = ask("Add a finding from that answer? thing, action or rule (enter to skip): ")
+          kind = kind.to_s.strip.downcase
+          break if kind.empty?
+
+          typed = typed_finding(kind) or next say("  I only know thing, action and rule.")
+          config = KINDS["SME::Interview.Propose#{kind.capitalize}"]
+          number = propose(config, typed) or next
+          decide(config, number, true)
+        end
+      end
+
+      def typed_finding(kind)
+        case kind
+        when "thing" then named("Name" => "name", "Identified by" => "identifier")
+        when "action" then typed_action
+        when "rule" then named("The rule, in the expert's words" => "statement")
+        end
+      end
+
+      def typed_action
+        fields = named("Name" => "name", "On which thing" => "thing", "It announces (event)" => "event") or return nil
+        fields.merge("creates" => TRUE_WORDS.include?(ask("  Does it create the thing? [y/N] ").to_s.strip.downcase))
+      end
+
+      def named(prompts)
+        fields = prompts.to_h { |label, key| [key, ask("  #{label}: ").to_s.strip] }
+        fields.values.all? { |v| !v.empty? } ? fields : nil
+      end
+
+      def suggest_enough
+        return if @suggested || !enough?
+
+        @suggested = true
+        say("\nI think we have enough to start. Type done to finish, or keep answering.")
+      end
+
+      def enough?
+        plain = InterviewDraft.from_record(current)
+        InterviewDraft.accepted(plain, :things).any? && InterviewDraft.accepted(plain, :actions).any?
+      end
+
+      def conclude
+        current.conclude!
+        @finished = true
+      rescue StandardError => e
+        say("Not finished yet: #{reason(e)}.")
+      end
+
+      def cancel
+        current.cancel!
+        @cancelled = @finished = true
+        say("Stopped. Nothing was written.")
+      end
+
+      def end_of_input
+        conclude
+        cancel unless @finished
+      end
+
+      def accept?(label)
+        !%w[n no].include?(ask(label).to_s.strip.downcase)
+      end
+
+      def state
+        plain = InterviewDraft.from_record(current)
+        { task: format(TASK, subject: @subject), subject: @subject, expert: @expert, verbs: VERBS,
+          exchanges: plain[:exchanges].each_with_index.map { |e, i| e.slice(:question, :answer).merge(number: i + 1) },
+          accepted: accepted_state(plain), gaps: gaps(plain) }
+      end
+
+      def accepted_state(plain)
+        { things:  InterviewDraft.accepted(plain, :things).map { |f| f.slice(:name, :identifier) },
+          actions: InterviewDraft.accepted(plain, :actions).map { |f| f.slice(:name, :thing, :event, :creates) },
+          rules:   InterviewDraft.accepted(plain, :rules).map { |f| f.slice(:statement) } }
+      end
+
+      # What the interview has not yet pinned down, in words a model can act on.
+      def gaps(plain)
+        things = InterviewDraft.accepted(plain, :things).map { |t| t[:name].to_s }
+        actions = InterviewDraft.accepted(plain, :actions)
+        gaps = things.reject { |t| actions.any? { |a| a[:thing] == t } }.map { |t| "nothing is yet said to happen to #{t}" }
+        gaps += things.reject { |t| actions.any? { |a| a[:thing] == t && a[:creates] } }.map { |t| "nothing yet creates #{t}" }
+        unplaced = actions.reject { |a| things.include?(a[:thing].to_s) }
+        gaps + unplaced.map { |a| "#{a[:name]} names #{a[:thing]}, not yet a thing" }
+      end
+
+      def reason(error) = error.message.sub(/\A[A-Z]\w* refused\s+[—-]\s+/, "").strip
+
+      def ask(label)
+        @output.print(label)
+        @input.gets&.chomp
+      end
+
+      def say(text) = @output.puts(text)
+    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,10 @@ 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",
+      tickets:   "lib/hecks/tickets/bluebook/*.bluebook",
       tenancy:   "lib/hecks/tenancy/bluebook/*.bluebook",
+      sme:       "lib/hecks/sme/bluebook/*.bluebook",
       fixture:   "spec/fixtures/**/*.bluebook"
     }.freeze
 
@@ -232,14 +235,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 +310,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