hecks 7.0.0 → 7.1.0

data/lib/hecks/shape_ledger/edge_hygiene.rb

@@ -5,7 +5,8 @@ require "json"
 module Hecks
   module ShapeLedger
     # Finds the translation edges that no longer earn their file; it deletes nothing. The graph is
-    # a bluebook's edge files plus its recorded implicit moves, aimed at the current shape. A file is:
+    # a bluebook's edge files plus its recorded implicit moves, aimed at the current shape. A file
+    # is:
     #
     # - a **self-loop** when its `from` equals its `to`.
     # - a **fork** branch when two edges leave a label and both reach the current shape; the branch
@@ -19,11 +20,13 @@ module Hecks
       # One edge: the file that declares it (nil for a recorded implicit move) and its two labels.
       Edge = Struct.new(:path, :from, :to)
 
-      # The list beside the ledger of stale edges already known, each a finding key. A listed edge is
+      # The list beside the ledger of stale edges already known, each a finding key. A listed edge
+      # is
       # reported as a warning and does not fail the check; any other stale edge fails it.
       KNOWN_FILE = "known_stale_edges.json"
 
-      # One problem: its kind, the bluebook, the file to remove, a stable key naming the edge, and what
+      # One problem: its kind, the bluebook, the file to remove, a stable key naming the edge, and
+      # what
       # to do.
       Finding = Struct.new(:kind, :domain, :path, :key, :message, keyword_init: true)
 
@@ -42,7 +45,8 @@ module Hecks
         listed.map { |finding| "\nwarning, known stale edge (#{KNOWN_FILE}) #{lines([finding]).first}" }.join
       end
 
-      # @return [Array<String>] the finding keys of the known stale edges, empty when there is no list
+      # @return [Array<String>] the finding keys of the known stale edges, empty when there is no
+      #   list
       def known_stale(path) = File.exist?(path) ? JSON.parse(File.read(path)) : []
 
       # @param directory [String] the domain directory holding `translations/`
@@ -144,7 +148,8 @@ module Hecks
 
       def leads_to?(label, current, graph) = label == current || reached_from(label, graph).include?(current)
 
-      # @return [Array<String>] every label a chain of edges leads to from one label, itself included
+      # @return [Array<String>] every label a chain of edges leads to from one label, itself
+      #   included
       def reached_from(label, graph)
         seen = [label]
         seen.each { |at| graph.each { |edge| seen << edge.to if edge.from == at && !seen.include?(edge.to) } }

data/lib/hecks/shape_ledger.rb

@@ -130,7 +130,7 @@ module Hecks
       "#{name} moved with no edge. A change that only adds needs no edge file: settle it in one step " \
         "with `hecks conformance_run.check_shape_ledger! --confirm --additive --wait`, which the boot and " \
         "the mint treat as an implicit empty edge from #{from} to #{now}. Data that is renamed or reshaped " \
-        "needs rules: `hecks query era.scaffold_translation domain.value=<directory>` writes them, reading " \
+        "needs rules: `hecks era.scaffold_translation domain.value=<directory>` writes them, reading " \
         "the eras from the database the domain's own world names."
     end
 

data/lib/hecks/storehouse/audit.rb

@@ -13,7 +13,8 @@ module Hecks
       # CamelCase word takes an underscore.
       CAMEL_CASE_BOUNDARY = /([a-z\d])([A-Z])/
 
-      # The last segment of a qualified constant name, such as `TypeMismatch` in `Runtime::TypeMismatch`.
+      # The last segment of a qualified constant name, such as `TypeMismatch` in
+      # `Runtime::TypeMismatch`.
       UNQUALIFIED_NAME = /[^:]+\z/
 
       # Kept under Hecks::CacheDir, not the domain directory (part of the domain's

data/lib/hecks/storehouse/identity.rb

@@ -1,13 +1,16 @@
 module Hecks
   module Storehouse
-    # The ids a call used, named in its result: the record it addressed, and the references its arguments
+    # The ids a call used, named in its result: the record it addressed, and the references its
+    # arguments
     # named. Extended onto `Storehouse`.
     module Identity
-      # The arguments that name an id a call used: a run key, an earlier run it refers to, and the checkout
+      # The arguments that name an id a call used: a run key, an earlier run it refers to, and the
+      # checkout
       # and branch it resolved to.
       IDENTITY_KEYS = %i[run from checkout branch].freeze
 
-      # The ids a call used: the record it addressed, and the references its arguments named, each unwrapped
+      # The ids a call used: the record it addressed, and the references its arguments named, each
+      # unwrapped
       # to its value. Absent ones are left out.
       # :nodoc:
       def ids_of(request, outcome)

data/lib/hecks/storehouse.rb

@@ -29,7 +29,8 @@ module Hecks
     SOURCE_TAGS = %w[process-manager operator hook sidequest-agent cascade daemon].freeze
 
     # Which surface a call came in through, so the audit line says what made it: a person at a shell
-    # (`cli`), an agent over the MCP server (`mcp`), or the domain itself (`policy`, `saga`, `reaction`).
+    # (`cli`), an agent over the MCP server (`mcp`), or the domain itself (`policy`, `saga`,
+    # `reaction`).
     SURFACES = %w[cli mcp policy saga reaction].freeze
 
     # The root every domain path resolves under; HECKS_STOREHOUSE_ROOT widens it.

data/lib/hecks/tickets/bluebook/tickets.bluebook

@@ -387,11 +387,12 @@ Hecks.bluebook "Tickets" do
       emits "WorkStarted"
     end
 
-    # The claim's area overlapped another started step's, or it would start more steps than the
-    # cap allows: the WorkAreas or WorkLimits port refuses it by name, and the step goes back to
-    # the plan with the refusal as its reason.
+    # A started step that may not go on goes back to the plan with the refusal as its reason: its
+    # area overlapped another started step's, it would start more steps than the cap allows (the
+    # WorkAreas or WorkLimits port refuses it by name), or the architect's review of its plan said
+    # rethink and the coder session handed it back.
     command "Yield" do
-      goal "Return a step whose area another started step holds, with the refusal"
+      goal "Return a started step to the plan, with the refusal that sent it back"
 
       reference_to Work
       attribute :reason, WorkText, sets: true

data/lib/hecks/tools/ci_workflows.rb

@@ -16,7 +16,8 @@ module Hecks
     # A workflow with no row is hand-written and left alone. With `--check` nothing is written: the
     # tool answers 1 and names each file that differs from its rows.
     module CiWorkflows
-      # The directory of the bluebook that declares the rows, which attaches the CiPipeline bluebook.
+      # The directory of the bluebook that declares the rows, which attaches the CiPipeline
+      # bluebook.
       BLUEBOOK_DIRECTORY = File.expand_path("../ci_workflows", __dir__)
 
       # The directory `ports/` and `adapters/` live under, loaded before the rows are.

data/lib/hecks/tools/document.rb

@@ -32,12 +32,23 @@ module Hecks
 
         bluebook = boot_bluebook(path)
         begin
-          puts Projector.call(projection, bluebook: bluebook, options: aggregate ? { aggregate: aggregate } : {})
+          puts Projector.call(projection, bluebook: bluebook, options: options_for(projection, path, aggregate))
         rescue Runtime::NotFound => e
           abort e.message
         end
       end
 
+      # The projection's options: the aggregate it narrows to, and for `:narrate` the `.examples`
+      # files under the domain, whose goals it tells as use cases (ADR 0173).
+      #
+      # @api private
+      def options_for(projection, path, aggregate)
+        options = aggregate ? { aggregate: aggregate } : {}
+        return options unless projection == :narrate
+
+        options.merge(examples: Dir.glob(File.join(path, "**", "*.examples")))
+      end
+
       # The domain's own bluebook, not a framework member it attached: insertion
       # order, the same distinction `Runtime::Loader.dispatcher_for` draws.
       #

data/lib/hecks/tools/downstream_model_check.rb

@@ -4,7 +4,8 @@ require "fileutils"
 
 module Hecks
   module Tools
-    # The model check a domain repository runs in its CI, generated from Hecks' own definition of it:
+    # The model check a domain repository runs in its CI, generated from Hecks' own definition of
+    # it:
     # the client profile, over the domain's bluebooks, from the hecks the Gemfile pins.
     #
     # A downstream repository commits the file this writes (`.github/workflows/model-check.yml`) and
@@ -80,7 +81,8 @@ module Hecks
         YAML
       end
 
-      # Writes the workflow under `root`, or with `check` compares it and reports whether it is current.
+      # Writes the workflow under `root`, or with `check` compares it and reports whether it is
+      # current.
       #
       # @param root [String] the checkout
       # @param domain_directory [String] see {workflow}

data/lib/hecks/tools/fuzz_sweep/shards.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../tools"
+require_relative "../shard_planner"
 
 module Hecks
   module Tools
@@ -44,23 +45,8 @@ module Hecks
         # @param costs [Hash{String => Float}] each domain directory's cost, perhaps lacking some
         # @return [Array<Array<String>>] the domains of each shard, each in the order `domains` has
         def partition(domains, shards, costs = {})
-          price = prices(domains, costs)
-          order = domains.each_index.sort_by { |index| [-price[index], domains[index]] }
-          deal(order, price, shards).map { |indexes| indexes.sort.map { |index| domains[index] } }
-        end
-
-        # @param order [Array<Integer>] the domain positions, in the order to deal them
-        # @param price [Array<Float>] each position's cost
-        # @param shards [Integer] how many shards to deal into
-        # @return [Array<Array<Integer>>] the positions each shard took, each to the lightest shard
-        #   so far, the lowest numbered when they tie
-        def deal(order, price, shards)
-          loads = Array.new(shards, 0.0)
-          order.each_with_object(Array.new(shards) { [] }) do |index, taken|
-            lightest = loads.each_index.min_by { |shard| [loads[shard], shard] }
-            loads[lightest] += price[index]
-            taken[lightest] << index
-          end
+          dealt = ShardPlanner.partition(domains, shards, price_table(domains, costs))
+          dealt.map { |members| domains.select { |domain| members.include?(domain) } }
         end
 
         # @param domains [Array<String>] the domain directories
@@ -84,7 +70,7 @@ module Hecks
           split = partition(domains, shards, costs)
           raise NotAPartition, "the shards are not a partition of the domains" unless split.flatten.sort == domains.sort
 
-          price = domains.zip(prices(domains, costs)).to_h
+          price = price_table(domains, costs)
           split.each_with_index.flat_map do |members, index|
             members.map { |domain| row("#{index + 1}/#{shards}", price[domain], domain.delete_prefix("#{root}/")) }
           end
@@ -112,7 +98,7 @@ module Hecks
         # @param costs [Hash{String => Float}] each domain directory's cost
         # @return [Array<String>] the same domains, dearest first, ties in path order
         def dearest_first(domains, costs)
-          price = domains.zip(prices(domains, costs)).to_h
+          price = price_table(domains, costs)
           domains.sort_by { |domain| [-price[domain], domain] }
         end
 
@@ -137,18 +123,11 @@ module Hecks
               .to_h { |line| line.split(":", 2).then { |dir, seconds| [File.join(root, dir), Float(seconds)] } }
         end
 
-        # @return [Array<Float>] each domain's cost, a missing one at the table's median
-        def prices(domains, costs)
-          fallback = median(costs.values) || FLAT_COST
-          domains.map { |domain| costs.fetch(domain, fallback) }
-        end
-
-        def median(values)
-          return nil if values.empty?
+        # @return [Hash{String => Float}] each domain's cost, a missing one at the table's median
+        def price_table(domains, costs) = ShardPlanner.prices(domains, costs, ->(_domain) { FLAT_COST })
 
-          ranked = values.sort
-          (ranked[(ranked.size - 1) / 2] + ranked[ranked.size / 2]) / 2.0
-        end
+        # @return [Array<Float>] each domain's cost, in the order of `domains`
+        def prices(domains, costs) = price_table(domains, costs).values_at(*domains)
       end
     end
   end

data/lib/hecks/tools/model_check/examination.rb

@@ -40,7 +40,8 @@ module Hecks
           edges = booted.flat_map do |_, registry|
             Projections::ContextRelationships.call(registry: registry, owners: owners)
           end
-          findings = Bluebook::ModelCheck.context_cycle_findings(edges.uniq) + context_map_findings(booted, owners)
+          findings = Bluebook::ModelCheck.context_cycle_findings(edges.uniq) +
+                     classification_findings(booted, owners) + context_map_findings(booted, owners)
           return true if findings.empty?
 
           puts "── contexts"
@@ -56,11 +57,33 @@ module Hecks
           booted.flat_map do |_, registry|
             registry.context_maps.flat_map do |map|
               edges = Projections::ContextRelationships.call(registry: registry, owners: owners)
-              Bluebook::ModelCheck.context_map_findings(map, edges)
+              Bluebook::ModelCheck.context_map_findings(map, edges) +
+                Bluebook::ModelCheck.core_conforms_findings(map, classifications_of(registry))
             end
           end
         end
 
+        # What each booted system's classifications say about its own wiring (ADR 0172). Each system
+        # is read alone: two systems may each declare a context of the same name.
+        #
+        # @api private
+        # @return [Array<Bluebook::ModelCheck::Finding>]
+        def classification_findings(booted, owners)
+          booted.flat_map do |_, registry|
+            edges = Projections::ContextRelationships.call(registry: registry, owners: owners)
+            Bluebook::ModelCheck.generic_depends_on_core_findings(edges, classifications_of(registry))
+          end
+        end
+
+        # Each context's classification (`core`, `supporting`, `generic`), as its bluebook declares it.
+        #
+        # @api private
+        # @return [Hash{String => String}] only the contexts that declare one
+        def classifications_of(registry)
+          classified = registry.bluebooks.values.select(&:classification)
+          classified.to_h { |declaration| [declaration.name.to_s, declaration.classification.to_s] }
+        end
+
         # @api private
         def emitted_events_of(booted)
           booted.flat_map do |_, registry|

data/lib/hecks/tools/move_disables.rb

@@ -121,7 +121,8 @@ module Hecks
       # Removes the directives from one file's lines.
       #
       # @param lines [Array<String>] the file's lines, without their newlines
-      # @return [Array(Array<String>, String)] the cops the directives named, and the file's new text
+      # @return [Array(Array<String>, String)] the cops the directives named, and the file's new
+      #   text
       def strip(lines)
         touched = []
         out = lines.filter_map { |line| keep_line(line, touched) }
@@ -190,7 +191,8 @@ module Hecks
 
       # @param cop [String] a cop name
       # @param paths [Array<String>] the `Exclude` entries
-      # @return [String] the cop's header, its reason, and its `Exclude`, to replace an existing header
+      # @return [String] the cop's header, its reason, and its `Exclude`, to replace an existing
+      #   header
       def merged_block(cop, paths) = ["#{cop}:", "  # #{REASONS.fetch(cop)}", "  Exclude:", *paths].join("\n")
 
       # @param cop [String] a cop name

data/lib/hecks/tools/regeneration_run/scratch.rb

@@ -32,7 +32,8 @@ module Hecks
         end
 
         # Puts back, in the scratch crate, every module the named domains do not own, as the tree
-        # has it: a run of some domains rewrites the shared bluebooks and the grammar as its own last
+        # has it: a run of some domains rewrites the shared bluebooks and the grammar as its own
+        # last
         # writer would, which is not what the whole corpus's last writer left in the tree.
         #
         # @param scratch [String] the scratch crate

data/lib/hecks/tools/rspec_shard_files.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require "parallel_tests/test/runner"
+require_relative "shard_planner"
 
 module Hecks
   module Tools
     # The command behind `hecks shard_specs`: prints the spec files assigned to one group
-    # (1-indexed) of a runtime-balanced N-way split. `rspec_shard` in ci-rspec.yml passes the
-    # committed runtime baseline so every leg agrees.
+    # (1-indexed) of an N-way split by the shared `ShardPlanner`. It is the split a leg of
+    # `rspec_shard` in ci-rspec.yml falls back on when the plan job's plan cannot be read; with no
+    # runtime log it balances by file size, which every leg computes alike.
     #
     # It does not use `parallel_rspec --only-group`, which forces one process per leg; this suite
-    # is CPU-bound, so each leg would use one of four vCPUs. The group's list comes from
-    # `tests_in_groups`, leaving `parallel_rspec` its own workers.
+    # is CPU-bound, so each leg would use one of four vCPUs. The group's list comes from the
+    # planner, leaving `parallel_rspec` its own workers.
     module RspecShardFiles
       USAGE = "usage: hecks shard_specs <group 1-indexed> <num_groups> [runtime_log_path]"
 
@@ -60,21 +61,17 @@ module Hecks
               "refusing to hand parallel_rspec nothing to run"
       end
 
-      # Splits the files by recorded runtime, falling back to file size on a cold cache.
-      #
-      # `allowed_missing_percent` covers gaps inside a log, not a missing file (`Runner.runtimes`
-      # raises `Errno::ENOENT`).
+      # Splits the files by the seconds in the runtime log when one is given and exists, and by file
+      # size otherwise.
       #
       # @param files [Array<String>] the spec files, relative to the checkout
       # @param num_groups [Integer] how many groups to split into
-      # @param runtime_log [String, nil] the runtime log's path, used when the file exists
+      # @param runtime_log [String, nil] a log of `path:seconds` lines, used when the file exists
       # @return [Array<Array<String>>] the files of each group
       def groups_of(files, num_groups, runtime_log)
-        options = { group_by: :runtime, allowed_missing_percent: 100 }
-        options[:runtime_log] = runtime_log if runtime_log && File.exist?(runtime_log)
-        ParallelTests::Test::Runner.tests_in_groups(files, num_groups, **options)
-      rescue Errno::ENOENT
-        ParallelTests::Test::Runner.tests_in_groups(files, num_groups, group_by: :filesize)
+        table = runtime_log && File.exist?(runtime_log) ? ShardPlanner.parse(File.read(runtime_log)) : {}
+        prices = ShardPlanner.prices(files, table, ->(file) { File.size(file) })
+        ShardPlanner.partition(files, num_groups, prices)
       end
     end
   end

data/lib/hecks/tools/sequence_script.rb

@@ -10,7 +10,7 @@ module Hecks
     #
     #   hecks generate_sequence <domain> [--seed N] [--steps N] [--adversarial fraction]
     #
-    # `--adversarial` mutates the sequence as `hecks quality_control query sweep.run` does; 0 (off)
+    # `--adversarial` mutates the sequence as `hecks quality_control sweep.run` does; 0 (off)
     # by default.
     module SequenceScript
       USAGE = "usage: hecks generate_sequence <domain> [--seed N] [--steps N] [--adversarial FRACTION]"

data/lib/hecks/tools/shard_planner.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Tools
+    # The longest-processing-time split every sharded CI family shares: spec files of the rspec and
+    # postgres io jobs, and the domains of a fuzz sweep. It is a pure function of the items, the
+    # shard count and the prices, so the same input gives the same partition.
+    #
+    # A price is a recorded run time when the table holds one for the item, the table's median when
+    # it holds others but not this one, and the item's size when there is no table at all.
+    module ShardPlanner
+      # One `key:seconds` line; seconds can arrive in exponent form (`9.69e-05`). Anything else,
+      # such as RSpec's "Run options" line, is not a timing.
+      LINE = /\A(?<key>\S+):(?<seconds>\d+(?:\.\d+)?(?:e-?\d+)?)\z/
+
+      module_function
+
+      # @param text [String] lines of `key:seconds`
+      # @return [Hash{String => Float}] the seconds of each key; a malformed line is skipped
+      def parse(text)
+        lines = text.to_s.lines.map(&:strip)
+        timed = lines.filter_map { |line| LINE.match(line) }
+        timed.to_h { |match| [match[:key], Float(match[:seconds])] }
+      end
+
+      # @param texts [Array<String>] several shards' timing logs
+      # @return [Hash{String => Float}] one table; a key in two logs keeps the later seconds
+      def merge(texts) = texts.reduce({}) { |table, text| table.merge(parse(text)) }
+
+      # @param items [Array<String>] what is to be split
+      # @param table [Hash{String => Float}] recorded seconds, perhaps empty or lacking some items
+      # @param sizes [#call] answers an item's size in bytes, used only when the table is empty
+      # @return [Hash{String => Float}] each item's price
+      def prices(items, table, sizes)
+        return items.to_h { |item| [item, sizes.call(item).to_f] } if table.empty?
+
+        fallback = median(table.values)
+        items.to_h { |item| [item, table.fetch(item, fallback)] }
+      end
+
+      # @param items [Array<String>] what is to be split, each unique
+      # @param groups [Integer] how many groups to deal into
+      # @param prices [Hash{String => Float}] each item's price
+      # @return [Array<Array<String>>] the items of each group, dearest first, each to the lightest
+      #   group so far, the lowest numbered when they tie
+      def partition(items, groups, prices)
+        loads = Array.new(groups, 0.0)
+        dealt = Array.new(groups) { [] }
+        items.sort_by { |item| [-prices.fetch(item), item] }.each do |item|
+          lightest = loads.each_index.min_by { |group| [loads[group], group] }
+          loads[lightest] += prices.fetch(item)
+          dealt[lightest] << item
+        end
+        dealt
+      end
+
+      # @param values [Array<Float>] at least one
+      # @return [Float] the middle value
+      def median(values)
+        ranked = values.sort
+        (ranked[(ranked.size - 1) / 2] + ranked[ranked.size / 2]) / 2.0
+      end
+    end
+  end
+end

data/lib/hecks/tools/stage_progress.rb

@@ -10,7 +10,8 @@ module Hecks
     # standard output, so a pipe still receives only the result.
     class StageProgress
       class << self
-        # Whether the lines are left out, as `-q` asks: set by the launcher for the length of a line.
+        # Whether the lines are left out, as `-q` asks: set by the launcher for the length of a
+        # line.
         # @return [Boolean]
         attr_accessor :quiet
       end

data/lib/hecks/tools/stress_concurrency_specs.rb

@@ -8,7 +8,8 @@ require_relative "stress_concurrency_specs/reporting"
 
 module Hecks
   module Tools
-    # The command behind `hecks test_suite_run.stress_concurrency!`: reruns the thread-safety specs under many
+    # The command behind `hecks test_suite_run.stress_concurrency!`: reruns the thread-safety specs
+    # under many
     # seeds, several OS processes at a time. A clean run shows only "not in this many tries", never
     # "impossible".
     #

data/lib/hecks/version.rb

@@ -1,5 +1,5 @@
 module Hecks
   # Read directly by the gemspec, so this file must never require the
   # rest of the gem (its dependencies aren't resolved yet at that point).
-  VERSION = "7.0.0".freeze # rust/host/HECKS_RELEASE names the same release
+  VERSION = "7.1.0".freeze # rust/host/HECKS_RELEASE names the same release
 end

data/lib/hecks/vocabulary.rb

@@ -115,7 +115,7 @@ module Hecks
         {"name"=>"textarea", "pattern"=>"\\b(text|body|note|notes|description|message|comment)\\b", "resolves_to"=>"kind"}.freeze
       ].freeze,
       "GateCheck" => [
-        {"name"=>"rspec", "id"=>"rspec", "title"=>"rspec (parallel)", "runs_in"=>"ci", "argv"=>"", "script"=>"# Workers are grouped by this machine's own last timings, kept under the git directory\n# (shared by every worktree, never committed). CI's committed baseline leaves out the io\n# specs this run includes, so it only seeds the first run; each run then rewrites the log.\nlog=\"$(git rev-parse --git-common-dir)/hecks_rspec_runtime.log\"\n[ -f \"$log\" ] || cp .github/rspec_runtime_baseline.log \"$log\"\nbundle exec parallel_rspec spec -n {workers} --group-by runtime --runtime-log \"$log\" --allowed-missing 100 \\\n  -o \"--format progress --format ParallelTests::RSpec::RuntimeLogger --out $log\"\n", "blocked"=>"the suite is red."}.freeze,
+        {"name"=>"rspec", "id"=>"rspec", "title"=>"rspec (parallel)", "runs_in"=>"ci", "argv"=>"", "script"=>"# Workers are grouped by this machine's own last timings, kept under the git directory\n# (shared by every worktree, never committed); the first run, with none, groups by file size and\n# writes the log.\nlog=\"$(git rev-parse --git-common-dir)/hecks_rspec_runtime.log\"\nif [ -f \"$log\" ]; then grouping=(--group-by runtime --runtime-log \"$log\" --allowed-missing 100); else grouping=(--group-by filesize); fi\nbundle exec parallel_rspec spec -n {workers} \"${grouping[@]}\" \\\n  -o \"--format progress --format ParallelTests::RSpec::RuntimeLogger --out $log\"\n", "blocked"=>"the suite is red."}.freeze,
         {"name"=>"fuzzing", "id"=>"fuzzing", "title"=>"spec/fuzzing, which the parallel run above excludes", "argv"=>"bundle exec rspec spec/fuzzing --tag fuzzing", "script"=>"", "blocked"=>"spec/fuzzing is red."}.freeze,
         {"name"=>"query_agreement", "id"=>"query_agreement", "title"=>"adapter agreement, one declared query and every engine giving the same answer", "argv"=>"bundle exec rspec spec/adapters/query_agreement_spec.rb --tag io", "script"=>"", "blocked"=>"the engines disagree about a declared query; one of them is wrong, and a self-consistent adapter spec cannot tell which."}.freeze,
         {"name"=>"engine_agreement", "id"=>"engine_agreement", "title"=>"engine agreement, every declared comparator on both engines", "argv"=>"bundle exec exe/hecks conformance_run.check_engine_agreement! --wait", "script"=>"", "blocked"=>"a comparator is missing a shared case or a cross-engine spec."}.freeze,
@@ -149,8 +149,8 @@ module Hecks
         {"name"=>"ci_gates", "id"=>"ci_gates", "title"=>"ci gates, the CiGate rows must match the marked regions of the workflows", "argv"=>"bundle exec exe/hecks regeneration_run.project_ci_gates! --wait", "script"=>"", "blocked"=>"a CiGate row changed with no projection, or a region was edited by hand; run `hecks regeneration_run.project_ci_gates! --confirm`."}.freeze,
         {"name"=>"ci_pipeline", "id"=>"ci_pipeline", "title"=>"ci pipeline, the workflow rows must match the files they project", "argv"=>"bundle exec exe/hecks regeneration_run.project_ci_pipeline! --wait", "script"=>"", "blocked"=>"a workflow row changed with no projection, or a projected workflow was edited by hand; run `hecks regeneration_run.project_ci_pipeline! --confirm`."}.freeze,
         {"name"=>"tools_doc", "id"=>"tools_doc", "title"=>"tools doc, docs/tools.md must match the RetiredScript rows", "argv"=>"bundle exec exe/hecks regeneration_run.project_tools_doc! --wait", "script"=>"", "blocked"=>"a command's arguments changed with no regenerated doc; run `hecks regeneration_run.project_tools_doc! --confirm`."}.freeze,
-        {"name"=>"rust_coverage", "id"=>"rust_coverage", "title"=>"rust coverage, every generated module", "argv"=>"bundle exec exe/hecks query corpus_run.corpus_rust_coverage --wait", "script"=>"", "blocked"=>"a construct a domain declares has no generated Rust, or an entry on RUST_COVERAGE_PENDING is now fixed and must be deleted."}.freeze,
-        {"name"=>"rust_coverage_codegen", "id"=>"rust_coverage_codegen", "title"=>"rust coverage against hecks-codegen's own manifest, pizzas governance identity banking meta", "argv"=>"", "script"=>"for module in pizzas governance identity banking meta; do\n  bundle exec exe/hecks query build.rust_coverage module_name=$module codegen=rust --wait\ndone\n", "blocked"=>"hecks-codegen generated nothing for a construct a domain declares."}.freeze,
+        {"name"=>"rust_coverage", "id"=>"rust_coverage", "title"=>"rust coverage, every generated module", "argv"=>"bundle exec exe/hecks corpus_run.corpus_rust_coverage --wait", "script"=>"", "blocked"=>"a construct a domain declares has no generated Rust, or an entry on RUST_COVERAGE_PENDING is now fixed and must be deleted."}.freeze,
+        {"name"=>"rust_coverage_codegen", "id"=>"rust_coverage_codegen", "title"=>"rust coverage against hecks-codegen's own manifest, pizzas governance identity banking meta", "argv"=>"", "script"=>"for module in pizzas governance identity banking meta; do\n  bundle exec exe/hecks build.rust_coverage module_name=$module codegen=rust --wait\ndone\n", "blocked"=>"hecks-codegen generated nothing for a construct a domain declares."}.freeze,
         {"name"=>"kernel_coverage", "id"=>"kernel_coverage", "title"=>"rust kernel coverage, every capability variant has a kernel file", "argv"=>"bundle exec exe/hecks kernel_run.measure_kernel_coverage! --wait", "script"=>"", "blocked"=>"a capability's enum variant has no rust/src/kernel file behind it."}.freeze,
         {"name"=>"rust_vocabulary_drift", "id"=>"rust_vocabulary_drift", "title"=>"rust vocabulary, the kernel vocab tables regenerated must match the committed ones", "argv"=>"", "script"=>"bundle exec exe/hecks language_run.project_rust_vocabulary! --confirm --wait\ngit diff --exit-code -- rust/src/kernel/vocab/\nuntracked=\"$(git status --porcelain --untracked-files=all -- rust/src/kernel/vocab/)\"\nif [ -n \"$untracked\" ]; then\n  echo \"rust/src/kernel/vocab has uncommitted generated files:\" >&2\n  echo \"$untracked\" >&2\n  exit 1\nfi\n", "blocked"=>"the generated kernel vocab tables are stale or untracked; the check rewrote them, so commit the result."}.freeze
       ].freeze,
@@ -209,7 +209,7 @@ module Hecks
         {"name"=>"cadence_seconds", "type"=>"Integer", "meaning"=>"Minimum gap in seconds between one tick's report and the next dispatch; 0 is immediately. Read by the `/loop hecks_qa` caller, not by any script."}.freeze,
         {"name"=>"pr_cap_per_day", "type"=>"Integer", "meaning"=>"Most PRs (Patch plus Improvement) `hecks quality_control Patch.open!` opens per calendar day; 0 is uncapped."}.freeze,
         {"name"=>"widening_tiers", "type"=>"Array", "meaning"=>"Fuzz depth by `Target.clean_streak`, in three discrete tiers, read by `SweepDepth.for_streak`. The last row (`upto: Float::INFINITY`) is the ceiling."}.freeze,
-        {"name"=>"sweep_max_parallel", "type"=>"Integer", "meaning"=>"How many `hecks quality_control query sweep.run <target>` children `--all` keeps running at once."}.freeze,
+        {"name"=>"sweep_max_parallel", "type"=>"Integer", "meaning"=>"How many `hecks quality_control sweep.run <target>` children `--all` keeps running at once."}.freeze,
         {"name"=>"liveness_fallback_seconds", "type"=>"Integer", "meaning"=>"How long the `/loop hecks_qa` caller waits for a tick's report before assuming it stalled."}.freeze,
         {"name"=>"draft_only", "type"=>"Boolean", "meaning"=>"Whether `hecks quality_control Patch.open!` opens its PR as a draft; false opens it ready for review."}.freeze,
         {"name"=>"auto_merge", "type"=>"Boolean", "meaning"=>"Whether `hecks quality_control Patch.open!` queues the PR for auto-merge once it is open."}.freeze,
@@ -218,15 +218,15 @@ module Hecks
         {"name"=>"corpus_splice_probability", "type"=>"Numeric", "meaning"=>"Fraction (0.0..1.0) of seeds that start from a prefix of an earlier seed's new coverage. Off by default: measured, it trades breadth for depth (banking reached 1.41x the deep-state tuples, chess lost 0.12x of all tuples), while favoring rare verbs alone never lost."}.freeze,
         {"name"=>"favor_rare_verbs", "type"=>"Integer", "meaning"=>"How many of the least-hit verbs the next seed weights up; 0 turns the lever off."}.freeze,
         {"name"=>"runtime_coverage_feedback", "type"=>"Boolean", "meaning"=>"Whether guided generation also admits a seed to the corpus for reaching a new line or branch of the Ruby runtime (`Hecks::Fuzzing::RuntimeCoverage`), not only a new (verb, kind, state, mutation, outcome) tuple. Off by default: tracing every line slows each seed."}.freeze,
-        {"name"=>"self_consistency_checks", "type"=>"Boolean", "meaning"=>"Whether `hecks quality_control query sweep.run` also runs the self-consistency pass (cold rehydration, replay idempotency, value-object JSON round trip) on the same generated sequence."}.freeze,
-        {"name"=>"shrink_budget", "type"=>"Integer", "meaning"=>"Candidate replays `hecks quality_control query sweep.run` may spend shrinking one surprised check; 0 turns shrinking off. `concurrency` is never shrunk: a race does not reproduce on demand."}.freeze,
+        {"name"=>"self_consistency_checks", "type"=>"Boolean", "meaning"=>"Whether `hecks quality_control sweep.run` also runs the self-consistency pass (cold rehydration, replay idempotency, value-object JSON round trip) on the same generated sequence."}.freeze,
+        {"name"=>"shrink_budget", "type"=>"Integer", "meaning"=>"Candidate replays `hecks quality_control sweep.run` may spend shrinking one surprised check; 0 turns shrinking off. `concurrency` is never shrunk: a race does not reproduce on demand."}.freeze,
         {"name"=>"yield_weight_seconds", "type"=>"Integer", "meaning"=>"Seconds of staleness that one point of yield score is worth in `RotationPriority.pick`. Zero would make yield invisible, so pick a number that lets it matter."}.freeze,
         {"name"=>"yield_decay_percent", "type"=>"Integer", "meaning"=>"Percent of the prior yield score kept at each release, so recent findings dominate. Applied by the caller: the mutation language cannot express \"decay, then add\" in `Release`."}.freeze,
         {"name"=>"rotation_stale_floor_seconds", "type"=>"Integer", "meaning"=>"Once a waiting target is this stale, `RotationPriority.pick` takes it whatever its yield score, so a quiet target cannot starve."}.freeze,
-        {"name"=>"persistence_parity_seed_cap", "type"=>"Integer", "meaning"=>"Ceiling on `--seeds` for `--persistence-parity`, which pays for real Postgres per dispatch. `hecks quality_control query sweep.run` clamps down, never up, and prints a note."}.freeze,
+        {"name"=>"persistence_parity_seed_cap", "type"=>"Integer", "meaning"=>"Ceiling on `--seeds` for `--persistence-parity`, which pays for real Postgres per dispatch. `hecks quality_control sweep.run` clamps down, never up, and prints a note."}.freeze,
         {"name"=>"concurrency_seed_cap", "type"=>"Integer", "meaning"=>"Ceiling on `--seeds` for the concurrency mode, which needs two disposable schemas per seed."}.freeze,
         {"name"=>"adapter_parity_pairs", "type"=>"Hash", "meaning"=>"The two adapters each adapter-parity mode compares, by mode name; a new pairing is a new entry. `adapter_parity_sqlite` needs no `database:`/`schema:` because sqlite has no disposable database."}.freeze,
-        {"name"=>"modes", "type"=>"Hash", "meaning"=>"Which comparison modes `hecks quality_control query sweep.run` may run: the enabled ones intersected with what `TargetCapabilities.infer(path)` finds in the target. `--modes a,b,c` overrides for one run. `wasm_front` and `adapter_parity_postgres` are off because nothing runs them; the others are built and off because their I/O cost across the rotation is unmeasured. `hecks quality_control query sweep.run` refuses to start when a mode outside `TargetCapabilities::RUNNABLE_MODES` is enabled."}.freeze,
+        {"name"=>"modes", "type"=>"Hash", "meaning"=>"Which comparison modes `hecks quality_control sweep.run` may run: the enabled ones intersected with what `TargetCapabilities.infer(path)` finds in the target. `--modes a,b,c` overrides for one run. `wasm_front` and `adapter_parity_postgres` are off because nothing runs them; the others are built and off because their I/O cost across the rotation is unmeasured. `hecks quality_control sweep.run` refuses to start when a mode outside `TargetCapabilities::RUNNABLE_MODES` is enabled."}.freeze,
         {"name"=>"role_draw_probability", "type"=>"Numeric", "meaning"=>"How often a generated role-gated command step carries a drawn caller (`role:`/`actor_id:`); 0 turns the draw off."}.freeze,
         {"name"=>"dry_run_fraction", "type"=>"Numeric", "meaning"=>"Fraction of generated command steps offered as a dry run instead of a real dispatch; 0 is off. Kept low: a dry run creates no state for later steps to act on."}.freeze,
         {"name"=>"generated_domains_per_tick", "type"=>"Integer", "meaning"=>"How many generated domains one `hecks quality_control sweep.tick` checks after the rotation sweep; 0 skips the step."}.freeze,
@@ -589,7 +589,6 @@ module Hecks
         {"script"=>"rspec_shard_files", "section"=>"Codebase", "aggregate"=>"TestSuiteRun", "verb"=>"shard_specs"}.freeze,
         {"script"=>"rspec_io_parallel_files", "section"=>"Codebase", "aggregate"=>"TestSuiteRun", "verb"=>"list_io_parallel_specs"}.freeze,
         {"script"=>"rspec_io_parallel_files", "section"=>"Codebase", "aggregate"=>"TestSuiteRun", "verb"=>"write_io_parallel_spec_list"}.freeze,
-        {"script"=>"refresh_rspec_runtime_baseline", "section"=>"Codebase", "aggregate"=>"TestSuiteRun", "verb"=>"refresh_runtime_baseline"}.freeze,
         {"script"=>"spec_example", "section"=>"Codebase", "aggregate"=>"TestSuiteRun", "verb"=>"run_spec_example"}.freeze,
         {"script"=>"stress_concurrency_specs", "section"=>"Codebase", "aggregate"=>"TestSuiteRun", "verb"=>"stress_concurrency"}.freeze,
         {"script"=>"regenerate_persistence_legacy_fixtures", "section"=>"Codebase", "aggregate"=>"TestSuiteRun", "verb"=>"regenerate_legacy_fixtures"}.freeze,

data/lib/hecks.rb

@@ -98,9 +98,12 @@ module Hecks
     # @param shared [String, nil] a shared-root override; see `Runtime::Loader.boot_files`
     # @param install_driving [Boolean] install the `Widget::Item.Add`-style facade
     # @param environment [String, nil] environment name passed to the selected-file loader
+    # @param adapters [Array<String>, nil] exactly the `.adapter` files to load, leaving the
+    #   project's own unloaded; nil keeps the loader's own choice
     # @return [Runtime::Dispatcher, Adapters::Lambda::RemoteDispatcher] the domain's dispatcher
-    def boot_files(paths, shared: nil, install_driving: true, environment: Assembly::FROM_ENV)
-      Assembly.boot_files(paths, shared: shared, install_driving: install_driving, environment: environment)
+    def boot_files(paths, shared: nil, install_driving: true, environment: Assembly::FROM_ENV, adapters: nil)
+      Assembly.boot_files(paths, shared: shared, install_driving: install_driving, environment: environment,
+                                 adapters: adapters)
     end
 
     # Installs the Ruby driving adapter (`Widget::Item.Add(...)`) over a dispatcher built by hand.

data/rust/host/HECKS_RELEASE

@@ -1 +1 @@
-7.0.0
+7.1.0

data/rust/parser/src/emit.rs

@@ -1030,7 +1030,8 @@ fn ruby_value_json(value: &ruby_value::Value) -> JsonValue {
 }
 
 /// One declared adapter, keys in the order the Ruby side prints them; an adapter that provides
-/// capabilities adds `provides`, and a plugin adds `answers` and `runs` after them.
+/// capabilities adds `provides`, one that stays inside adds `stays_inside`, and a plugin adds
+/// `answers` and `runs` after them.
 pub fn adapter_json(adapter: &ir::Adapter) -> JsonValue {
     let JsonValue::Object(mut keys) = declared_adapter_json(adapter) else {
         unreachable!("an adapter is a JSON object")
@@ -1041,6 +1042,9 @@ pub fn adapter_json(adapter: &ir::Adapter) -> JsonValue {
             JsonValue::strings(&adapter.provides),
         ));
     }
+    if adapter.stays_inside {
+        keys.push(("stays_inside".to_string(), JsonValue::Bool(true)));
+    }
     if let Some(runs) = &adapter.runs {
         keys.push(("answers".to_string(), JsonValue::strings(&adapter.answers)));
         keys.push(("runs".to_string(), JsonValue::str(runs.clone())));

data/rust/parser/src/ir.rs

@@ -486,4 +486,6 @@ pub struct Adapter {
     pub runs: Option<String>,
     // The capabilities the adapter provides beyond its port's contract, in declaration order.
     pub provides: Vec<String>,
+    // `stays_inside`: the adapter reaches nothing outside the process and the checkout (ADR 0171).
+    pub stays_inside: bool,
 }