hecks 7.0.0 → 7.1.0

data/lib/hecks/hecks/hecks.hecksagon

@@ -5,7 +5,7 @@ Hecks.hecksagon "Hecks" do
   # Expression, Tenancy, Deploy, Site, Tickets, Composer and QualityControl (the last three bring
   # their own ports), and Coder and Fixer, whose events Tickets and QualityControl react to.
   %w[Bluebook Hecksagon World Adapter Port Translation Expression Tenancy Deploy Site Tickets Composer QualityControl
-     Coder Fixer]
+     Coder Fixer PipelineBoard Pipeline]
     .each { |declaration| attaches declaration }
   # Persistence is not bound here, so the domain is in Memory. A copy opts in with a
   # hecks.local.hecksagon whose `persisted_by` the attached bluebooks inherit (ADR 0136).
@@ -96,6 +96,16 @@ Hecks.hecksagon "Hecks" do
     end
   end
 
+  # Where a boarding's outcome is recorded: the boarded checkout's own launcher records it in that
+  # checkout's store. The train's own store stays Memory.
+  Hecks::SendTrain.port "PushRecords" do
+    asks "RecordOutcome", to: SendTrain do
+      attribute :run, RunKey
+      answers "OutcomeRecorded"
+      refuses "OutcomeUnrecorded"
+    end
+  end
+
   Hecks::PushRehearsal.port "Rehearsing" do
     asks "Trial", to: PushRehearsal do
       attribute :run, RunKey
@@ -106,6 +116,18 @@ Hecks.hecksagon "Hecks" do
     answers_query "Due"
   end
 
+  Hecks::RedFlag.port "Flagging" do
+    %w[Hoist SignIn Lower Survey].each do |step|
+      asks step, to: RedFlag do
+        attribute :run, RunKey
+        answers "FlagAnswered"
+        refuses "FlagRefused"
+      end
+    end
+
+    answers_query "Status"
+  end
+
   Hecks::QaQuiesce.port "Quiescing" do
     asks "Mark", to: QaQuiesce do
       attribute :run, RunKey
@@ -131,6 +153,15 @@ Hecks.hecksagon "Hecks" do
     end
   end
 
+  Hecks::SendTrain.port "Leftovers" do
+    asks "Leftovers", to: SendTrain do
+      attribute :run, RunKey
+      attribute :pushed, Word
+      answers "LeftoversListed"
+      refuses "LeftoversRefused"
+    end
+  end
+
   Hecks::Workspace.port "Reading" do
     answers_query "Status"
     answers_query "Changes"
@@ -196,6 +227,12 @@ Hecks.hecksagon "Hecks" do
       refuses "RemovalRefused"
     end
 
+    asks "DropBranch", to: Landing do
+      attribute :run, RunKey
+      answers "DiscardAnswered"
+      refuses "DiscardRefused"
+    end
+
     answers_query "Unlanded"
   end
 
@@ -209,6 +246,43 @@ Hecks.hecksagon "Hecks" do
     end
   end
 
+  # The outside an integration of main reaches: the open runs an advance steps, a clean copy of
+  # main for a verification, the push train's own copy for a boarding, and GitHub's CI runs.
+  Hecks::Integration.port "Integrating" do
+    asks "Step", to: Integration do
+      attribute :run, RunKey
+      answers "AdvanceAnswered"
+      refuses "AdvanceRefused"
+    end
+  end
+
+  Hecks::Integration.port "MainVerifying" do
+    asks "Check", to: Integration do
+      attribute :run, RunKey
+      attribute :landed, Word
+      answers "VerifyAnswered"
+      refuses "VerifyRefused"
+    end
+  end
+
+  Hecks::Integration.port "MainBoarding" do
+    asks "Embark", to: Integration do
+      attribute :run, RunKey
+      attribute :landed, Word
+      answers "BoardAnswered"
+      refuses "BoardRefused"
+    end
+  end
+
+  Hecks::Integration.port "CiRuns" do
+    asks "Watch", to: Integration do
+      attribute :run, RunKey
+      attribute :landed, Word
+      answers "ObserveAnswered"
+      refuses "ObserveRefused"
+    end
+  end
+
   Hecks::ReviewRequest.port "GitHubPullRequests" do
     asks "Create", to: ReviewRequest do
       attribute :run, RunKey
@@ -240,8 +314,8 @@ Hecks.hecksagon "Hecks" do
     end
   end
 
-  # The outside an agent run reaches: it finds the directory, starts the background session, and
-  # reports the state the session is in. The state is judged in the bluebook, not here.
+  # The outside an agent run reaches: it finds the directory and the agents, starts the background
+  # session, and reports the state its job is in. The state is judged in the bluebook, not here.
   Hecks::AgentRun.port "Agents" do
     asks "Locate", to: AgentRun do
       attribute :run, RunKey
@@ -255,10 +329,18 @@ Hecks.hecksagon "Hecks" do
       refuses "StartRefused"
     end
 
-    asks "Examine", to: AgentRun do
+    # The state a session's job is in, with the state the run last recorded beside it.
+    asks "ReadJob", to: AgentRun do
       attribute :run, RunKey
-      answers "SessionChecked"
-      refuses "CheckRefused"
+      answers "JobRead"
+      refuses "JobUnread"
+    end
+
+    # The same reading, taken once a just-started session has had a few seconds to fail.
+    asks "AwaitJob", to: AgentRun do
+      attribute :run, RunKey
+      answers "JobRead"
+      refuses "JobUnread"
     end
 
     # Whether a person took the session over is a fact about its transcript; the bluebook judges it.
@@ -866,3 +948,21 @@ Hecks.hecksagon "Tenancy" do
     trigger Tenant::Register, with: { slug: :slug, domain: :domain, realm: :realm, schema: :schema }
   end
 end
+
+# A rehearsal that would mint is the record a mint reads: QualityControl's Maintenance keeps the verdict and
+# the watermark the copy held, so Maintenance.MintEra finds it by this run (the mint plan's watermark guard).
+# QualityControl is attached here, so the seam is its translation of the migrate bluebook's audit, not an
+# `across` dispatch. It listens beside Judge, on the same audit and the same condition, because the rehearsal
+# is already five reactions deep at Judge and a reaction to RehearsalJudged would pass the dispatcher's depth bound.
+Hecks.hecksagon "QualityControl" do
+  subscribe "Hecks.RehearsalAudited"
+
+  translates "RecordVerdictWhenNothingWouldStopTheMint" do
+    on RehearsalRun::RehearsalAudited
+    where do
+      (minting.value != "next" || edge_present.value) && refusal_total.value == 0
+    end
+    trigger Maintenance::RecordRehearsalVerdict, with: { run: :run, domain: :rehearsed_domain,
+                                                          watermark: :watermark, rehearsal_verdict: "would_mint" }
+  end
+end

data/lib/hecks/hecks/hecks.world

@@ -45,6 +45,9 @@
 # **test_scope** `suite_runs_in` names where the full suite runs ("ci": a local run of it is refused by name) and
 # `spec_files_limit` is the most spec files one local `run_spec_files!` or `run_impacted_specs!` call runs.
 #
+# **event_log** `path` is the append-only file the runtime writes events and policy deliveries to (one JSON line each,
+# names and outcomes, never payloads) and `max_bytes` the size at which it moves to `<path>.1`; absent, nothing is written.
+#
 # **landing** `stale_minutes` is how long a landing's ticket may go without a heartbeat before the next one treats
 # it as abandoned and removes it (30 when absent); `wait_minutes` is how long a landing waits for its turn in the
 # line before it gives up (40 when absent); `shell_lock` names a lock directory an older brief makes by hand,
@@ -64,6 +67,10 @@ Hecks.world "Hecks" do
   # Locally `test_suite_run.run_suite!` is refused, and `run_spec_files!` and `run_impacted_specs!` run at
   # most `spec_files_limit` files per call; CI is detected by the environment (`CI`, `GITHUB_ACTIONS`).
   test_scope "Local", suite_runs_in: "ci", spec_files_limit: 25
+  # The runtime appends one JSON line per event and per policy delivery here, so a reader such as the
+  # PipelineBoard sees the domains that persist nothing (the push train runs in Memory). A client's
+  # world declares no `event_log`, so a client writes no file. The file rotates at `max_bytes`.
+  event_log "EventTap", path: "~/.claude/hecks-dev/events.jsonl", max_bytes: 5_000_000
   launcher "Launcher", run_keys: true,
                        settled: %w[package.vendor package.revendor package.release
                                   operation.bootstrap_admin smoke_run.run
@@ -72,11 +79,12 @@ Hecks.world "Hecks" do
                                   preview_run.url preview_run.list preview_run.deploy
                                   preview_run.destroy preview_run.login companion_roll.run
                                   handover.clear rehearsal_run.request send_train.board
-                                  landing.land landing.train landing.retire agent_run.dispatch agent_run.check],
+                                  landing.land landing.train landing.retire landing.discard agent_run.dispatch agent_run.check],
                        unknown_runs: %w[rehearsal_run.rehearsal_outcome],
                        renamed: { "push_train.push" => "send_train.send", "pull_request.merge" => "review_request.take", "checkout.log" => "workspace.history" },
                        names: { "config" => "workspace.settings", "doctor" => "workspace.doctor", "mcp" => "server.serve_mcp", "console" => "operation.open_console", "init" => "launch.init",
                                 "interview" => "launch.interview", "package.check" => "registry.check",
+                                "agent_run.check_all" => "session_sweep.check_all",
                                 "package.digest" => "registry.digest",
                                 "package.release" => "registry.release" },
                        streams: %w[Follow],

data/lib/hecks/hecks/migrate/migrate.bluebook

@@ -908,6 +908,10 @@ Hecks.bluebook "Hecks" do
         attribute :unchecked,     list_of(Limit), sets: true
         attribute :released,      Switch, sets: true
         attribute :kept,          Report, optional: true, sets: true
+        # Carried, not kept: the rehearsed bluebook's name and the ledger watermark the copy held, plain, as
+        # Maintenance.RecordRehearsalVerdict takes them.
+        attribute :rehearsed_domain, String
+        attribute :watermark,     Integer
 
 
         emits RehearsalAudited
@@ -1035,7 +1039,8 @@ Hecks.bluebook "Hecks" do
                                             rust_rows_examined: :rust_rows_examined,
                                             aggregates_examined: :aggregates_examined, reason: :reason,
                                             parity: :parity, unchecked: :unchecked,
-                                            released: :released, kept: :kept }
+                                            released: :released, kept: :kept,
+                                            rehearsed_domain: :rehearsed_domain, watermark: :watermark }
     end
 
     policy "JudgeWhenNothingWouldStopTheMint" do

data/lib/hecks/hecks/redflag/redflag.bluebook

@@ -0,0 +1,249 @@
+Hecks.bluebook "Hecks" do
+  domain_module "Redflag" do
+    vision "Main red is a red flag: everyone working hears it, checks in to help, and stops landing until CI is green again."
+
+    # One request against the standing flag of the repository: raise it, note another red run on it,
+    # check in to help, or lower it. The flag itself is a marker in the repository's git directory, so
+    # Landing and SendTrain read it from every worktree. A CI run of main that completes red raises it
+    # (Integration.CiFailed, or `RedFlag.sync!`), and one that completes green lowers it. One flag
+    # stands at a time: a second red run is recorded on it. Anything can listen to the events
+    # RedFlagRaised, RedFlagRunNoted, RedFlagCheckedIn and RedFlagCleared through the ordinary journal.
+    aggregate "RedFlag" do
+      description "One request against main's red flag: raised, noted, checked in to, lowered, or refused."
+      created_by "RedFlag.raise!"
+
+      attribute :run,      RunKey
+      attribute :commit,   Word,   optional: true
+      attribute :detail,   Report, optional: true
+      attribute :rows,     Report, optional: true
+      attribute :session,  Word,   optional: true
+      attribute :taking,   Word,   optional: true
+      attribute :checkout, Word,   optional: true
+      attribute :flag,     Word,   optional: true
+      attribute :ci_run,   Report, optional: true
+      attribute :jobs,     Report, optional: true
+      attribute :output,   Report, optional: true
+      attribute :refusal,  Report, optional: true
+      identified_by :run
+
+      value_object "RunKey" do
+        attribute :value, String, matches: :present
+      end
+
+      value_object "Word" do
+        attribute :value, String, matches: :present
+      end
+
+      value_object "Report" do
+        attribute :value, String
+      end
+
+      value_object "Document" do
+        attribute :text, String
+      end
+
+      lifecycle :status, default: "requested" do
+        mark :failure, "refused"
+        transition "Record"  => "raised",     from: "requested"
+        transition "Note"    => "noted",      from: "requested"
+        transition "Welcome" => "checked_in", from: "requested"
+        transition "Lift"    => "cleared",    from: "requested"
+        transition "Settle"  => "idle",       from: "requested"
+        transition "Decline" => "refused",    from: "requested"
+        mark :terminal, "raised", "noted", "checked_in", "cleared", "idle", "refused"
+      end
+
+      command "Raise" do
+        role "System"
+        goal "Raise main's red flag for a red CI run, or record the run on the flag already standing"
+
+        attribute :run,      RunKey, sets: true
+        attribute :commit,   Word, sets: true
+        attribute :detail,   Report, optional: true, sets: true
+        attribute :rows,     Report, optional: true, sets: true
+        attribute :checkout, Word, optional: true, sets: true
+
+        emits RaiseRequested
+      end
+
+      command "CheckIn" do
+        role "Operator"
+        goal "Say who is helping with the red flag and what they take (a red-* Work row or a cause), so nobody fixes the same thing twice"
+
+        attribute :run,      RunKey, sets: true
+        attribute :session,  Word, sets: true
+        attribute :taking,   Word, sets: true
+        attribute :checkout, Word, optional: true, sets: true
+
+        emits CheckInRequested
+      end
+
+      command "Clear" do
+        role "System"
+        goal "Lower main's red flag for a green CI run, which lets landing and the push train resume"
+
+        attribute :run,      RunKey, sets: true
+        attribute :commit,   Word, optional: true, sets: true
+        attribute :checkout, Word, optional: true, sets: true
+
+        emits ClearRequested
+      end
+
+      command "Sync" do
+        role "Operator"
+        goal "Read main's newest CI run on GitHub and raise or lower the red flag to match it"
+
+        attribute :run,      RunKey, sets: true
+        attribute :checkout, Word, optional: true, sets: true
+
+        emits SyncRequested
+      end
+
+      command "Record" do
+        role "System"
+        goal "Record that the red flag was raised, with the main commit, CI run, failed jobs and red Work rows"
+
+        reference_to RedFlag
+        attribute :flag,   Word, sets: true
+        attribute :commit, Word, sets: true
+        attribute :ci_run, Report, optional: true, sets: true
+        attribute :jobs,   Report, optional: true, sets: true
+        attribute :rows,   Report, optional: true, sets: true
+
+        emits RedFlagRaised
+      end
+
+      command "Note" do
+        role "System"
+        goal "Record another red run on the flag that already stands"
+
+        reference_to RedFlag
+        attribute :flag,   Word, sets: true
+        attribute :commit, Word, sets: true
+        attribute :ci_run, Report, optional: true, sets: true
+        attribute :jobs,   Report, optional: true, sets: true
+
+        emits RedFlagRunNoted
+      end
+
+      command "Welcome" do
+        role "System"
+        goal "Record that a session checked in to help, and what it takes"
+
+        reference_to RedFlag
+        attribute :flag,    Word, sets: true
+        attribute :session, Word, sets: true
+        attribute :taking,  Word, sets: true
+
+        emits RedFlagCheckedIn
+      end
+
+      command "Lift" do
+        role "System"
+        goal "Record that the red flag was lowered by a green run"
+
+        reference_to RedFlag
+        attribute :flag,   Word, sets: true
+        attribute :commit, Word, optional: true, sets: true
+
+        emits RedFlagCleared
+      end
+
+      command "Settle" do
+        role "System"
+        goal "Record that there was nothing to change: no flag stood to lower, or CI is still running"
+
+        reference_to RedFlag
+        attribute :output, Report, sets: true
+
+        emits RedFlagUnchanged
+      end
+
+      command "Decline" do
+        role "System"
+        goal "Record why a request against the flag was refused"
+
+        reference_to RedFlag
+        attribute :refusal, Report, sets: true
+
+        emits RedFlagDeclined
+      end
+
+      query "Status" do
+        description "Whether main is flagged: the flag, its commit, red time, failed jobs and who is helping."
+        attribute :run, RunKey, optional: true
+        returns Document
+      end
+    end
+
+    policy "HoistWhenRaised" do
+      on      "RedFlag.RaiseRequested"
+      ask     :hoist, with: { run: :run }
+    end
+
+    policy "SignInWhenCheckedIn" do
+      on      "RedFlag.CheckInRequested"
+      ask     :sign_in, with: { run: :run }
+    end
+
+    policy "LowerWhenCleared" do
+      on      "RedFlag.ClearRequested"
+      ask     :lower, with: { run: :run }
+    end
+
+    policy "SurveyWhenSynced" do
+      on      "RedFlag.SyncRequested"
+      ask     :survey, with: { run: :run }
+    end
+
+    policy "RecordTheRaisedFlag" do
+      on      "RedFlag.FlagAnswered"
+      where   { outcome.value == "raised" }
+      trigger RedFlag::Record, with: { flag: :flag, commit: :commit, ci_run: :ci_run, jobs: :jobs, rows: :rows }
+    end
+
+    policy "RecordTheNotedRun" do
+      on      "RedFlag.FlagAnswered"
+      where   { outcome.value == "noted" }
+      trigger RedFlag::Note, with: { flag: :flag, commit: :commit, ci_run: :ci_run, jobs: :jobs }
+    end
+
+    policy "RecordTheCheckIn" do
+      on      "RedFlag.FlagAnswered"
+      where   { outcome.value == "checked_in" }
+      trigger RedFlag::Welcome, with: { flag: :flag, session: :session, taking: :taking }
+    end
+
+    policy "RecordTheClearedFlag" do
+      on      "RedFlag.FlagAnswered"
+      where   { outcome.value == "cleared" }
+      trigger RedFlag::Lift, with: { flag: :flag, commit: :commit }
+    end
+
+    policy "RecordTheUnchangedFlag" do
+      on      "RedFlag.FlagAnswered"
+      where   { outcome.value == "idle" }
+      trigger RedFlag::Settle, with: { output: :output }
+    end
+
+    policy "RecordTheRefusedFlag" do
+      on      "RedFlag.FlagRefused"
+      trigger RedFlag::Decline, with: { refusal: :refusal }
+    end
+
+    # A CI observation that ends red raises the flag; one that ends green lowers it. The policies hear
+    # the observation's answer, beside the ones that record it, so the chain stays within the
+    # reaction depth bound. The landed commit keys the request.
+    policy "RaiseTheFlagWhenCiFails" do
+      on      "Integration.ObserveAnswered"
+      where   { outcome.value == "failed" }
+      trigger RedFlag::Raise, with: { run: :landed, commit: :landed, detail: :report, checkout: :checkout }
+    end
+
+    policy "LowerTheFlagWhenCiPasses" do
+      on      "Integration.ObserveAnswered"
+      where   { outcome.value == "passed" }
+      trigger RedFlag::Clear, with: { run: :landed, commit: :landed, checkout: :checkout }
+    end
+  end
+end

data/lib/hecks/hecks/test/test.bluebook

@@ -107,20 +107,6 @@ Hecks.bluebook "Hecks" do
         attribute :value, String, pattern: '^(host|parser|json)$'
       end
 
-      command "RefreshRuntimeBaseline" do
-        role "Maintainer"
-        goal "Regenerate the committed runtime baselines the sharded jobs group from"
-
-        attribute :workers,  Count, default: 6, sets: true
-        attribute :from_run, RunId, optional: true, sets: true
-        attribute :run,      RunKey, sets: true
-        attribute :confirm,  Switch, optional: true, sets: true
-
-        sets :operation, to: "refresh_runtime_baseline"
-
-        emits RefreshRuntimeBaselineRequested
-      end
-
       command "RunSpecExample" do
         role "Maintainer"
         goal "Run one spec file filtered to one example, through the test runner in this process"
@@ -334,11 +320,6 @@ Hecks.bluebook "Hecks" do
       end
     end
 
-    policy "ExamineWhenRefreshRuntimeBaselineRequested" do
-      on      "TestSuiteRun.RefreshRuntimeBaselineRequested"
-      ask     :examine, with: { run: :run }
-    end
-
     policy "ExamineWhenRunSpecExampleRequested" do
       on      "TestSuiteRun.RunSpecExampleRequested"
       ask     :examine, with: { run: :run }

data/lib/hecks/language/adapter.bluebook

@@ -15,6 +15,9 @@ Hecks.bluebook "Adapter" do
     # What this adapter can do beyond its port's contract, such as `set_transform`. Absent is
     # not empty: most adapters provide nothing more.
     attribute :provides, list_of(AdapterCapability)
+    # Whether this adapter stays inside: it reaches no network, model or host beyond the process
+    # and the checkout, so a behaviors suite may load it (ADR 0171). Absent means it reaches outside.
+    attribute :stays_inside, Containment, optional: true
 
     # **A plugin answers named queries** — one that `runs` a wasm module says which queries it
     # answers, each qualified by bluebook and aggregate, and the runtime binds them to it.
@@ -48,6 +51,12 @@ Hecks.bluebook "Adapter" do
       attribute :value, String, matches: :snake_name
     end
 
+    # What `stays_inside` records: the one claim an adapter can make about its reach.
+    value_object "Containment" do
+      attribute :value, String
+      invariant("an adapter that says where it reaches stays inside") { value.to_s == "inside" }
+    end
+
     # The wasm module a plugin runs: a file beside its `.adapter`, never a path out of it.
     value_object "PluginModule" do
       attribute :value, String, pattern: '^[a-z0-9_-]+\.wasm$'
@@ -69,10 +78,13 @@ Hecks.bluebook "Adapter" do
       attribute :port, AdapterPortName, optional: true
       # Optional: only a plugin runs a wasm module.
       attribute :runs, PluginModule, optional: true
+      # Optional: only an adapter that says `stays_inside` holds it.
+      attribute :stays_inside, Containment, optional: true
 
       sets :name
       sets :port
       sets :runs
+      sets :stays_inside
 
       emits "AdapterDeclared"
     end
@@ -148,6 +160,7 @@ Hecks.bluebook "Adapter" do
 
 
       member word: "provides", context: "Adapter", body: "none", inner: "", opens: "", fills: "provides"
+      member word: "stays_inside", context: "Adapter", body: "none", inner: "", opens: "", fills: "stays_inside"
     end
 
     value_object "ArgumentSeed" do

data/lib/hecks/language/bluebook/vocabulary.bluebook

@@ -776,7 +776,7 @@ Hecks.bluebook "Bluebook" do
              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",
+             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."
       member name: "fuzzing", id: "fuzzing",
              title: "spec/fuzzing, which the parallel run above excludes",
@@ -954,13 +954,13 @@ Hecks.bluebook "Bluebook" do
              blocked: "a command's arguments changed with no regenerated doc; run `hecks regeneration_run.project_tools_doc! --confirm`."
       member name: "rust_coverage", id: "rust_coverage",
              title: "rust coverage, every generated module",
-             argv: "bundle exec exe/hecks query corpus_run.corpus_rust_coverage --wait",
+             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."
       member 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",
+             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."
       member name: "kernel_coverage", id: "kernel_coverage",
              title: "rust kernel coverage, every capability variant has a kernel file",
@@ -1129,7 +1129,7 @@ Hecks.bluebook "Bluebook" do
       member 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."
       member name: "sweep_max_parallel", type: "Integer",
-             meaning: "How many `hecks quality_control query sweep.run <target>` children `--all` keeps running at once."
+             meaning: "How many `hecks quality_control sweep.run <target>` children `--all` keeps running at once."
       member name: "liveness_fallback_seconds", type: "Integer",
              meaning: "How long the `/loop hecks_qa` caller waits for a tick's report before assuming it stalled."
       member name: "draft_only", type: "Boolean",
@@ -1147,9 +1147,9 @@ Hecks.bluebook "Bluebook" do
       member 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."
       member 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."
+             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."
       member 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."
+             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."
       member 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."
       member name: "yield_decay_percent", type: "Integer",
@@ -1157,13 +1157,13 @@ Hecks.bluebook "Bluebook" do
       member 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."
       member 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."
+             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."
       member name: "concurrency_seed_cap", type: "Integer",
              meaning: "Ceiling on `--seeds` for the concurrency mode, which needs two disposable schemas per seed."
       member 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."
       member 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."
+             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."
       member 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."
       member name: "dry_run_fraction", type: "Numeric",
@@ -1308,7 +1308,6 @@ Hecks.bluebook "Bluebook" do
       member script: "rspec_shard_files", section: "Codebase", aggregate: "TestSuiteRun", verb: "shard_specs"
       member script: "rspec_io_parallel_files", section: "Codebase", aggregate: "TestSuiteRun", verb: "list_io_parallel_specs"
       member script: "rspec_io_parallel_files", section: "Codebase", aggregate: "TestSuiteRun", verb: "write_io_parallel_spec_list"
-      member script: "refresh_rspec_runtime_baseline", section: "Codebase", aggregate: "TestSuiteRun", verb: "refresh_runtime_baseline"
       member script: "spec_example", section: "Codebase", aggregate: "TestSuiteRun", verb: "run_spec_example"
       member script: "stress_concurrency_specs", section: "Codebase", aggregate: "TestSuiteRun", verb: "stress_concurrency"
       member script: "regenerate_persistence_legacy_fixtures", section: "Codebase", aggregate: "TestSuiteRun", verb: "regenerate_legacy_fixtures"

data/lib/hecks/language/sentence/sentence.bluebook

@@ -187,6 +187,8 @@ Hecks.bluebook "Sentence" do
       member id: "examples_for",      context: "ExamplesFile", pattern: "Examples for: {name:words}",                                       opens: "Examples"
       member id: "background",        context: "Examples",  pattern: "Background:",                                                           opens: "Background"
       member id: "example",           context: "Examples",  pattern: "Example: {title:rest}",                                                 opens: "Example"
+      member id: "examples_goal",     context: "Examples",  pattern: "Goal: {goal:rest}",                                                     opens: "Goal"
+      member id: "goal_example",      context: "Goal",      pattern: "Example: {title:rest}",                                                 opens: "Example"
       member id: "person_role",       context: "Background", pattern: "{person:words} is (a|an) {role:words}",                                opens: ""
       member id: "given_step",        context: "Example",   pattern: "Given {step:rest}",                                                     opens: ""
       member id: "when_step",         context: "Example",   pattern: "When {step:rest}",                                                      opens: ""