hecks 3.0.3 → 3.0.5

data/lib/hecks/doors/cli_runner.rb

@@ -34,6 +34,62 @@ module Hecks
                  bluebook: plan[:bluebook], launcher: plan[:launcher])
       end
 
+      # Tails a question: asks, prints each new entry as one JSON line, and asks again from the
+      # cursor the answer gave, until the reader interrupts. Only for a question the `launcher`
+      # setting lists under `streams`, given `--stream`; `from_now` applies to the first ask only.
+      #
+      # @param runtime [Runtime::Dispatcher, Runtime::RemoteDispatcher] the booted domain
+      # @param argv [Array<String>] as for `call`, with `--stream`
+      # @param program [String] how the caller was invoked
+      # @param out [IO] where each entry's line goes
+      # @param err [IO] where a refusal goes
+      # @param max_polls [Integer, nil] stop after this many asks; unbounded when nil
+      # @return [Integer, nil] 0 or 1 for a stream, nil when `call` should run the line
+      def stream(runtime:, argv:, program: "hecks run", out: $stdout, err: $stderr, max_polls: nil)
+        plan = resolve(runtime, argv, program)
+        return if plan[:answer] || !LauncherOptions.streams?(plan[:launcher], plan[:spec])
+
+        words, streaming = LauncherOptions.take_stream(plan[:rest])
+        return unless streaming
+
+        tail(runtime, plan[:spec], CliDoor.arguments(plan[:spec], words), out, max_polls)
+        0
+      rescue Interrupt, Errno::EPIPE
+        0
+      rescue Runtime::NotFound, Runtime::TypeMismatch => e
+        err.puts("#{e.message}\n\n  #{program} #{plan[:name]} --help")
+        1
+      rescue *Runtime::DOMAIN_REFUSALS => e
+        err.puts(e.message)
+        1
+      end
+
+      # One ask after another, each from the cursor the last gave.
+      def tail(runtime, spec, args, out, max_polls)
+        args   = args.merge(wait: { value: 30 }) unless args.key?(:wait)
+        polls  = 0
+        cursor = nil
+        loop do
+          ask  = cursor ? args.except(:from_now).merge(since: { value: cursor }) : args
+          rows = runtime.query(spec[:verb], **ask)
+          row  = rows.first || {}
+          Array(row[:events]).each { |event| out.puts(JSON.generate(entry_line(JsonDoor.materialize(event)))) }
+          out.flush
+          cursor = row[:cursor]
+          polls += 1
+          break if cursor.nil? || (max_polls && polls >= max_polls)
+        end
+      end
+
+      # An entry as a line: its payload, which the answer holds as JSON text, back as an object.
+      def entry_line(event)
+        line = JSON.parse(JSON.generate(event))
+        line["payload"] = JSON.parse(line["payload"]) if line["payload"].is_a?(String)
+        line
+      rescue JSON::ParserError
+        line
+      end
+
       # Answers a command line that asks only for usage, from the projection alone.
       #
       # Needs a registry and no bound adapter, so a `Runtime::Loader::Described` serves: the
@@ -110,7 +166,7 @@ module Hecks
       # @param launcher [Hash, nil] the chapter's `launcher` world setting; nil when not opted in
       def dispatch(runtime, spec, name, rest, program, asking, bluebook: nil, launcher: nil)
         rest, wait = LauncherOptions.take_wait(spec, rest) if launcher
-        args = stamp_time(runtime, spec, CliDoor.arguments(spec, rest))
+        args = CliDoor.arguments(spec, rest)
 
         return answer_query(runtime, spec, args, wait) if spec[:kind] == :query
 
@@ -231,17 +287,6 @@ module Hecks
         rows.first[:text]
       end
 
-      # Fills in a `now` argument the caller left out, from the clock port; an explicit one wins.
-      #
-      # Done at the door, not in the runtime: a clock read inside the interpreter would give a
-      # replayed corpus step the replay day's time. Matched by the argument's name alone.
-      def stamp_time(runtime, spec, args)
-        return args unless spec[:arguments].any? { |argument| argument[:path].start_with?("now.") }
-        return args if args.key?(:now)
-
-        args.merge(now: { value: Ports::Clock.now(runtime.registry) })
-      end
-
       # The reactions one dispatch caused that the domain refused, as `refused_reactions:`.
       #
       # A policy's trigger that a `given` refuses is not the command's own refusal: the command

data/lib/hecks/doors/launcher_options.rb

@@ -1,3 +1,4 @@
+require "stringio"
 require_relative "../ports/identity_generation"
 require_relative "../runtime/errors"
 require_relative "cli_door"
@@ -15,9 +16,11 @@ module Hecks
     # - **run_keys** mints the `run` key of a creating command that was given none.
     # - **failure_states** are the lifecycle states `--wait` reports as a failure (exit 1).
     # - **names** maps a launcher name to the command it stands for (see `CliProjector`).
+    # - **streams** lists the questions `--stream` may tail, one JSON line per new entry.
     module LauncherOptions
       SETTING = "launcher".freeze
       WAIT    = "--wait".freeze
+      STREAM  = "--stream".freeze
       RUN_KEY = "run.value".freeze
 
       module_function
@@ -44,6 +47,23 @@ module Hecks
         { program: program, names: settings && settings[:names], mint_run_keys: settings && settings[:run_keys] }
       end
 
+      # Runs the block with standard error held back, so the wiring notes hecks prints about its own
+      # chapters (a Memory journal loses sagas on restart) do not open a console session. They are
+      # for an operator running a stored journal. A raised error still surfaces, unchanged.
+      #
+      # @param hold [Boolean] whether to hold standard error back; false runs the block as it is
+      # @yield the boot
+      # @return [Object] the block's value
+      def quietly(hold: true)
+        return yield unless hold
+
+        shown = $stderr
+        $stderr = StringIO.new
+        yield
+      ensure
+        $stderr = shown if hold
+      end
+
       # Takes `--wait` out of a verb's words, unless the verb declares a `wait` argument of its own.
       #
       # `--wait=false` (or `no`, `0`, `off`) is a `--wait` that was switched off; a bare `--wait`
@@ -67,6 +87,27 @@ module Hecks
         [rest, wait]
       end
 
+      # Whether a question may be tailed with `--stream`: the chapter's `launcher` setting lists it
+      # under `streams`, by the question's own name.
+      #
+      # @param launcher [Hash, nil] the chapter's `launcher` setting
+      # @param spec [Hash] the question's projected spec
+      # @return [Boolean] true for a question the setting names
+      def streams?(launcher, spec)
+        return false unless launcher && spec[:kind] == :query
+
+        Array(launcher[:streams]).map(&:to_s).include?(spec[:verb].to_s.split(/[.:]+/).last)
+      end
+
+      # Takes `--stream` out of a question's words.
+      #
+      # @param words [Array<String>] the words after the question
+      # @return [Array(Array<String>, Boolean)] the remaining words, and whether `--stream` was
+      #   given
+      def take_stream(words)
+        [words.reject { |word| word == STREAM }, words.include?(STREAM)]
+      end
+
       # @api private
       def wait_word?(word) = word == WAIT || word.start_with?("#{WAIT}=")
 

data/lib/hecks/fuzzing/properties.rb

@@ -39,7 +39,7 @@ module Hecks
         query_answers_match_reference:                    %w[Query#wheres Query#order_field Query#order_way Query#limit],
         paging_offset_partitions_correctly:               %w[Query#options],
         authorize_scopes_or_refuses:                      %w[Query#options],
-        guard_refusals_are_declared:                      %w[Command#givens Command#ensures],
+        guard_refusals_are_declared:                      %w[Command#givens Command#ensures Command#needs],
         lifecycle_guard_and_given_violations_are_refused: %w[Command#from Aggregate#preconditions Entity#preconditions],
         # Dispatch#command_name/with_spec aren't claimable feature names — the
         # coverage walk only reaches one level of entity nesting and Dispatch

data/lib/hecks/fuzzing/sequence_generator/adversary.rb

@@ -212,9 +212,10 @@ module Hecks
           if mapped.empty? && !entry.key?(:entity) && command.creates?
             mapped = command.attributes.map { |attribute| attribute.name.to_s }
           end
+          needed = needed_facts_of(entry)
           command.attributes.select do |attribute|
             name = attribute.name.to_s
-            mapped.include?(name) && args.key?(name) && !heads.include?(name)
+            mapped.include?(name) && args.key?(name) && !heads.include?(name) && !needed.include?(name)
           end
         end
 
@@ -352,12 +353,19 @@ module Hecks
         end
 
         def droppable_required_attributes(args, entry)
-          heads = identity_heads_of(entry)
+          heads  = identity_heads_of(entry)
+          needed = needed_facts_of(entry)
           entry[:command].attributes.reject(&:optional?).select do |attribute|
-            args.key?(attribute.name.to_s) && !heads.include?(attribute.name.to_s)
+            name = attribute.name.to_s
+            args.key?(name) && !heads.include?(name) && !needed.include?(name)
           end
         end
 
+        # The facts the command `needs`: the runtime answers them when a step leaves them out
+        # (each engine from its own clock), so a recorded step carries them and dropping one is not
+        # an absent-argument case.
+        def needed_facts_of(entry) = entry[:command].needs.map(&:to_s)
+
         # Aims a grant at a role some command declares; random role text would make `actor_known`
         # unreachable. Does nothing without the role draw.
         def steer_grant!(args, entry, catalog)

data/lib/hecks/fuzzing/sequence_generator/step_builder.rb

@@ -39,7 +39,7 @@ module Hecks
         # The caller draw and then the dry-run coin follow the mutation. The order
         # is part of the seed contract; both draw nothing when off.
         def build_command_step(runtime, catalog, entry)
-          args = args_for(entry[:command].attributes, entry[:aggregate])
+          args = args_for(entry[:command].attributes, entry[:aggregate], needed: entry[:command].needs.map(&:to_s))
           add_identity!(args, entry)
           steer_grant!(args, entry, catalog)
           mutations = adversarial_mutations!(args, entry, catalog)
@@ -76,7 +76,9 @@ module Hecks
           Hecks.as_caller(role: caller["role"], actor_id: caller["actor_id"], &)
         end
 
-        def args_for(attributes, aggregate)
+        # `needed` names the facts the runtime answers when a step leaves them out; a malformation
+        # never drops one, since each engine would fill it from its own clock.
+        def args_for(attributes, aggregate, needed: [])
           args = attributes.each_with_object({}) do |attribute, built|
             # Omitting an optional argument is an ordinary payload, not a malformation
             # (see OPTIONAL_OMITTED_PROBABILITY).
@@ -94,7 +96,7 @@ module Hecks
             end
           end
 
-          malform(args, attributes, aggregate)
+          malform(args, attributes, aggregate, needed)
         end
 
         # An array of 0-3 independently generated elements shaped like the bare
@@ -108,21 +110,21 @@ module Hecks
 
         # At most one malformation per step, so the check that fired is identifiable.
         # The rate stays low because refused steps reach no state.
-        def malform(args, attributes, aggregate)
+        def malform(args, attributes, aggregate, needed)
           return args if args.empty? || @random.rand >= MALFORMED_ARGUMENT_PROBABILITY
 
           case @random.rand(3)
           when 0 then corrupt_one(args, attributes, aggregate)
-          when 1 then drop_one(args, aggregate)
+          when 1 then drop_one(args, aggregate, needed)
           else        args.merge([InvalidValueGenerator.undeclared_argument(random: @random)].to_h)
           end
         end
 
         # Never drops the identity: an auto-minted id is unreproducible, so the
         # step's outcome could not be replayed.
-        def drop_one(args, aggregate)
+        def drop_one(args, aggregate, needed)
           identity  = (aggregate.identified_by || :id).to_s
-          droppable = args.keys - [identity, "id"]
+          droppable = args.keys - [identity, "id"] - needed
           return args if droppable.empty?
 
           args.reject { |name, _| name == droppable.sample(random: @random) }

data/lib/hecks/gate/stages.yml

@@ -0,0 +1,55 @@
+# The checks a stage runs before its change is let through. `hecks gate <stage>` reads this file and
+# the git pre-push hook calls it, so the list of checks lives here and nowhere else.
+#
+# A check is one command run from the repository root, all of a stage's checks at once:
+#   id       the name it is reported and selected by (`only=a,b`)
+#   title    the heading its output is printed under
+#   run      the program and its arguments; `{workers}` is half the machine's cores, at least one
+#   blocked  what a red check means and what to do about it
+#
+# `env` is set only where the caller has not set it: a push check has no use for the Hecks
+# domain's database, so it runs on Memory, as a pull-request run does in CI.
+pre_push:
+  env:
+    HECKS_ENVIRONMENT: memory
+  checks:
+    - id: rspec
+      title: rspec (parallel)
+      run: [bundle, exec, parallel_rspec, spec, -n, "{workers}"]
+      blocked: the suite is red.
+    - id: fuzzing
+      title: spec/fuzzing, which the parallel run above excludes
+      run: [bundle, exec, rspec, spec/fuzzing, --tag, fuzzing]
+      blocked: spec/fuzzing is red.
+    - id: query_agreement
+      title: adapter agreement, one declared query and every engine giving the same answer
+      run: [bundle, exec, rspec, spec/adapters/query_agreement_spec.rb, --tag, io]
+      blocked: the engines disagree about a declared query; one of them is wrong, and a self-consistent adapter spec cannot tell which.
+    - id: engine_agreement
+      title: engine agreement, every declared comparator on both engines
+      run: [bundle, exec, exe/hecks, check_engine_agreement, --wait]
+      blocked: a comparator is missing a shared case or a cross-engine spec.
+    - id: model_check
+      title: model check, unreachable states, dead transitions and orphaned handlers
+      run: [bundle, exec, exe/hecks, model_check, --wait]
+      blocked: the model checker found something.
+    - id: doc_coverage
+      title: docs coverage, words with no running example
+      run: [bundle, exec, exe/hecks, measure_doc_coverage, --wait]
+      blocked: the language ships something undocumented; write the missing sections and examples.
+    - id: rubocop
+      title: rubocop, the static style and correctness gate
+      run: [bundle, exec, rubocop, -c, .rubocop.yml]
+      blocked: rubocop found an offense.
+    - id: codegen_drift
+      title: codegen drift, the committed rust/src/generated/ must match a fresh regeneration
+      run: [bundle, exec, exe/hecks, regenerate_corpus, --check, --wait]
+      blocked: regenerating hits a diff, so the committed Rust is stale; run `hecks regenerate_corpus --confirm` and commit the result.
+    - id: comment_style
+      title: comment style, every comment under lib/hecks against docs/COMMENT_STYLE_GUIDE.md
+      run: [bundle, exec, exe/hecks, check_comments, paths=lib/hecks, --wait]
+      blocked: a comment breaks the style guide, such as a line past 100 characters; `hecks fix_comments` rewrites the mechanical ones, and the rest are shortened by hand. CI runs this same check.
+    - id: comment_blocks
+      title: comment blocks, no run of comment lines past ADR 0075's cap
+      run: [bundle, exec, exe/hecks, check_comments, "paths=lib,spec,examples", only=long_block, --wait]
+      blocked: a comment block ran past the cap; shorten it.

data/lib/hecks/grammar/expression.bluebook

@@ -211,6 +211,11 @@ Hecks.bluebook "Expression" do
 
       member strategy: "collapse_whitespace", source_token: "", replacement: "", boundary: "none", position: 1
       member strategy: "replace", source_token: ".length", replacement: ".size", boundary: "word", position: 2
+      # A duration written as a call on a whole number is that many seconds: `days(730)` is
+      # `63072000`. `source_token` names the call and `replacement` the seconds one unit is worth.
+      member strategy: "scale_call", source_token: "days",    replacement: "86400", boundary: "word", position: 3
+      member strategy: "scale_call", source_token: "hours",   replacement: "3600",  boundary: "word", position: 4
+      member strategy: "scale_call", source_token: "minutes", replacement: "60",    boundary: "word", position: 5
     end
 
     value_object "Reading" do
@@ -233,7 +238,7 @@ Hecks.bluebook "Expression" do
       attribute :position,     Position, optional: true
 
       given("a rule must name a linked strategy") do
-        strategy.value == "collapse_whitespace" || strategy.value == "replace"
+        strategy.value == "collapse_whitespace" || strategy.value == "replace" || strategy.value == "scale_call"
       end
 
       given("a rule must state its boundary") { boundary.value == "none" || boundary.value == "word" }

data/lib/hecks/grammar/expression_operators.json

@@ -1644,6 +1644,141 @@
         }
       }
     },
+    {
+      "verb": "Expression::Normalisation.Propose",
+      "args": {
+        "name": {
+          "value": "days_to_seconds"
+        },
+        "strategy": {
+          "value": "scale_call"
+        },
+        "source_token": {
+          "value": "days"
+        },
+        "replacement": {
+          "value": "86400"
+        },
+        "boundary": {
+          "value": "word"
+        },
+        "position": {
+          "value": 3
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Read",
+      "args": {
+        "name": {
+          "value": "days_to_seconds"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "text.gsub(/(?<![[:alnum:]_.])days\\(\\s*(\\d+)\\s*\\)/) { $1.to_i * 86400 }"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Admit",
+      "args": {
+        "name": {
+          "value": "days_to_seconds"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Propose",
+      "args": {
+        "name": {
+          "value": "hours_to_seconds"
+        },
+        "strategy": {
+          "value": "scale_call"
+        },
+        "source_token": {
+          "value": "hours"
+        },
+        "replacement": {
+          "value": "3600"
+        },
+        "boundary": {
+          "value": "word"
+        },
+        "position": {
+          "value": 4
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Read",
+      "args": {
+        "name": {
+          "value": "hours_to_seconds"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "text.gsub(/(?<![[:alnum:]_.])hours\\(\\s*(\\d+)\\s*\\)/) { $1.to_i * 3600 }"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Admit",
+      "args": {
+        "name": {
+          "value": "hours_to_seconds"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Propose",
+      "args": {
+        "name": {
+          "value": "minutes_to_seconds"
+        },
+        "strategy": {
+          "value": "scale_call"
+        },
+        "source_token": {
+          "value": "minutes"
+        },
+        "replacement": {
+          "value": "60"
+        },
+        "boundary": {
+          "value": "word"
+        },
+        "position": {
+          "value": 5
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Read",
+      "args": {
+        "name": {
+          "value": "minutes_to_seconds"
+        },
+        "target": {
+          "value": "ruby"
+        },
+        "form": {
+          "value": "text.gsub(/(?<![[:alnum:]_.])minutes\\(\\s*(\\d+)\\s*\\)/) { $1.to_i * 60 }"
+        }
+      }
+    },
+    {
+      "verb": "Expression::Normalisation.Admit",
+      "args": {
+        "name": {
+          "value": "minutes_to_seconds"
+        }
+      }
+    },
     {
       "verb": "Expression::Operator.Propose",
       "args": {

data/lib/hecks/hecks/adapters/codebase/gate.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "tree"
+require_relative "ruby_child"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # What Codebase's `GateRun` asks of the working tree: running a stage's checks.
+      #
+      # It runs `Hecks::Tools::Gate` in this process. The tool starts the stage's checks together,
+      # each as its own process, and answers 1 when any is red; the refusal is what the red checks
+      # printed, so `--wait` and the journal both say which check failed.
+      module Gate
+        # Every operation this family carries out.
+        OPERATIONS = %w[gate].freeze
+
+        module_function
+
+        # Runs the stage.
+        #
+        # @param _operation [String] `gate`
+        # @param held [Hash] the `GateRun` record's fields: `stage`, and `only` when given
+        # @param tree [Tree] the working tree, already known to be a hecks checkout
+        # @param shell [#capture, nil] unused: the tool runs in this process
+        # @return [String] which checks passed
+        # @raise [ConsoleCapture::Failure] with what the red checks printed
+        def call(_operation, held, tree, shell: nil)
+          plain = ->(name) { held[name].is_a?(Hash) ? held[name][:value] : held[name] }
+          only = plain.call(:only).to_s
+          argv = [plain.call(:stage).to_s, *("only=#{only}" unless only.empty?)]
+          RubyChild.new(tree).answer("gate", *argv).strip
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/codebase/regeneration.rb

@@ -7,7 +7,7 @@ module Hecks
   module Adapters
     module Codebase
       # What Codebase's `RegenerationRun` asks of the working tree: regenerating every corpus
-      # domain's committed Rust output.
+      # domain's committed Rust output, and projecting the CI path gates into the workflows.
       #
       # It runs `Hecks::Tools::RegenerationRun` in this process: the run forks once for each
       # domain, in a fixed order, because the domains share the files they stamp. With `check` it
@@ -16,7 +16,7 @@ module Hecks
       # files reports drift and writes only when it is confirmed.
       module Regeneration
         # Every operation this family carries out.
-        OPERATIONS = %w[regenerate_corpus].freeze
+        OPERATIONS = %w[regenerate_corpus project_ci_gates decide_ci_gate].freeze
 
         # How many lines of a script's output a refusal keeps.
         KEPT_LINES = 60
@@ -25,23 +25,43 @@ module Hecks
 
         # Carries out the regeneration.
         #
-        # @param _operation [String] `regenerate_corpus`
+        # @param operation [String] `regenerate_corpus` or `project_ci_gates`
         # @param held [Hash] the `RegenerationRun` record's fields: `check`, `confirm`
         # @param tree [Tree] the working tree, already known to be a hecks checkout
         # @param shell [#capture, nil] unused: the tool runs in this process
         # @return [String] how many domains were checked or regenerated
         # @raise [ConsoleCapture::Failure] with the difference, when a check finds drift, or with
         #   what the script printed when it ends badly
-        def call(_operation, held, tree, shell: nil)
+        def call(operation, held, tree, shell: nil)
           flag = ->(name) { (held[name].is_a?(Hash) ? held[name][:value] : held[name]) == true }
           check = flag.call(:check) || !flag.call(:confirm)
           child = RubyChild.new(tree)
+          return project_ci_gates(child, check) if operation == "project_ci_gates"
+          return decide_ci_gate(child, held) if operation == "decide_ci_gate"
+
           result = child.capture("regen_codegen_domains", *("--check" if check))
           raise ConsoleCapture::Failure, refusal(result) unless result.ok?
 
           summary(result.out, check)
         end
 
+        # @param child [RubyChild] the checkout's tool runner
+        # @param check [Boolean] whether to only compare
+        # @return [String] what the tool printed
+        # @raise [ConsoleCapture::Failure] with the stale workflows, when a check finds drift
+        def project_ci_gates(child, check)
+          child.answer("project_ci_gates", *("--check" if check))
+        end
+
+        # @param child [RubyChild] the checkout's tool runner
+        # @param held [Hash] the record's fields: `gate`, a `CiGate` row's name
+        # @return [String] `touched=true` or `touched=false`
+        # @raise [ConsoleCapture::Failure] when no row has that name
+        def decide_ci_gate(child, held)
+          gate = held[:gate].is_a?(Hash) ? held[:gate][:value] : held[:gate]
+          child.answer("decide_ci_gate", "gate=#{gate}")
+        end
+
         # @param output [String] what the script printed
         # @param check [Boolean] whether it only compared
         # @return [String] the verdict, with how many domains it covered

data/lib/hecks/hecks/adapters/codebase/source_tree.rb

@@ -5,6 +5,7 @@ require_relative "language"
 require_relative "kernel_tables"
 require_relative "conformance"
 require_relative "regeneration"
+require_relative "gate"
 require_relative "style"
 require_relative "codemods"
 require_relative "test_suite"
@@ -178,7 +179,8 @@ module Hecks
 
       # The task families, each carrying out the operations it lists.
       FAMILIES = [Codebase::Language, Codebase::KernelTables, Codebase::Conformance, Codebase::Regeneration,
-                  Codebase::Style, Codebase::Codemods, Codebase::TestSuite, Codebase::CorpusTasks, Codebase::Publishing].freeze
+                  Codebase::Gate, Codebase::Style, Codebase::Codemods, Codebase::TestSuite,
+                  Codebase::CorpusTasks, Codebase::Publishing].freeze
       private_constant :FAMILIES
 
       def tree = Codebase::Tree.new

data/lib/hecks/hecks/codebase.behaviors

@@ -79,6 +79,18 @@ Hecks.behaviors "Codebase" do
     expect refused: "must match"
   end
 
+  test "ProjectCiGates refuses a run that is not named" do
+    tests "ProjectCiGates", on: "RegenerationRun"
+    input run: { value: "" }
+    expect refused: "must match"
+  end
+
+  test "DecideCiGate refuses a run that is not named" do
+    tests "DecideCiGate", on: "RegenerationRun"
+    input run: { value: "" }, gate: { value: "runtime_changed" }
+    expect refused: "must match"
+  end
+
   test "CheckComments keeps a file with no violations as a completed check" do
     tests "CheckComments", on: "StyleRun"
     input paths: { value: "lib/hecks/canonical_json.rb" }, run: { value: "clean" }