hecks 3.10.0 → 3.12.0

data/lib/hecks/indifferent_key.rb

@@ -0,0 +1,20 @@
+module Hecks
+  # Reads a hash by key whichever way its keys are spelled, so the guess about Symbol or String
+  # keys is made in one place and `Hecks/SymbolStringKeyMix` can refuse it everywhere else.
+  #
+  # IndifferentKey.read({ "era" => "a1" }, :era)  # => "a1"
+  module IndifferentKey
+    module_function
+
+    # Reads `key` as given when present, else by its other spelling. Presence decides, not
+    # `||`, so a held `false` is not mistaken for an absent key.
+    #
+    # @param hash [Hash] a hash keyed by Symbols or by Strings
+    # @param key [Symbol, String] the key to read; its own spelling is tried first
+    # @return [Object, nil] the held value, or nil when neither spelling is present
+    def read(hash, key)
+      other = key.is_a?(Symbol) ? key.to_s : key.to_sym
+      hash.key?(key) ? hash[key] : hash[other]
+    end
+  end
+end

data/lib/hecks/language/adapter.bluebook

@@ -22,10 +22,18 @@ Hecks.bluebook "Adapter" do
     end
 
     value_object "AdapterField" do
-      attribute :value, String
+      attribute :value,   String
+      attribute :default, String, optional: true
       invariant("a field names itself") { !value.to_s.empty? }
     end
 
+    # The text of a field's declared default, such as `"data"` or `true`. A `{name}` in a string
+    # is filled from the aggregate the adapter is built for, so it names only what the framework
+    # can supply.
+    value_object "AdapterFieldDefault" do
+      attribute :value, String, pattern: '^(?:[^{}]|\{(?:name|storage_name)\})*$'
+    end
+
     command "Declare" do
       role "Deployment"
       goal "Register a real implementation of one resource port"
@@ -45,9 +53,10 @@ Hecks.bluebook "Adapter" do
       goal "Name a value this adapter's own world-level wiring must supply"
 
       reference_to Adapter
-      attribute :value, AdapterField
+      attribute :value,   AdapterField
+      attribute :default, AdapterFieldDefault, optional: true
 
-      sets :fields, append: { value: :value }
+      sets :fields, append: { value: :value, default: :default }
 
       emits "AdapterFieldAdded"
     end
@@ -104,6 +113,7 @@ Hecks.bluebook "Adapter" do
       member keyword: "adapter",         context: "File", at: "1", named: "", kind: "text", required: "true", fills: "name"
       member keyword: "port",            context: "Adapter", at: "1", named: "", kind: "text",   required: "true", fills: "port"
       member keyword: "field",           context: "Adapter", at: "1", named: "", kind: "symbol", required: "true", fills: "fields"
+      member keyword: "field",           context: "Adapter", at: "",  named: "default", kind: "literal", required: "false", fills: "default"
       member keyword: "secret",          context: "Adapter", at: "1", named: "", kind: "symbol", required: "true", fills: "secrets"
 
     end

data/lib/hecks/language/bluebook/aggregate.bluebook

@@ -18,6 +18,9 @@ Hecks.bluebook "Bluebook" do
     attribute :state_field,   IdentityField, optional: true
     attribute :state_start,   IdentityField, optional: true
     attribute :transitions,   list_of(Transition)
+    # Named meanings the lifecycle's states carry (`mark :holds_seat, "pending", "paid"`), one
+    # row per (mark, state), in declared order.
+    attribute :marks,         list_of(Mark)
     # Checked after every command, before save (ADR 0025). The same Rule shape as Command's
     # givens, declared again because a closed set or value object is aggregate-scoped here.
     attribute :invariants,    list_of(Rule)
@@ -74,6 +77,11 @@ Hecks.bluebook "Bluebook" do
       attribute :to_state,   String
     end
 
+    value_object "Mark" do
+      attribute :name,  String
+      attribute :state, String
+    end
+
     # The same shape as Command's "Rule" (behavior.bluebook), declared again rather than shared.
     value_object "Rule" do
       attribute :description, String
@@ -255,6 +263,18 @@ Hecks.bluebook "Bluebook" do
       emits TransitionAttached
     end
 
+    command "Mark" do
+      role "Language"
+      goal "Attach one state to a named meaning of the state machine"
+
+      attribute :name,  FieldName
+      attribute :state, FieldName
+
+      sets :marks, append: { name: :name, state: :state }
+
+      emits MarkAttached
+    end
+
     command "Seal" do
       role "Language"
       goal "Close an aggregate — the checks that need every declaration present"
@@ -366,6 +386,7 @@ Hecks.bluebook "Bluebook" do
       member word: "given",           context: "Aggregate", body: "source",   inner: "",              opens: "",               fills: "preconditions", resolves_via: "owner_keyed", disambiguator: "declared_by", calls: "given_impl"
       member word: "projects",        context: "Aggregate", body: "none",     inner: "",              opens: "",               fills: "projected_fields", calls: "projects_impl"
       member word: "transition",      context: "Lifecycle", body: "none", inner: "", opens: "",       fills: "transitions", calls: "transition_impl"
+      member word: "mark",            context: "Lifecycle", body: "none", inner: "", opens: "",       fills: "marks", calls: "mark_impl"
 
     end
 
@@ -429,6 +450,8 @@ Hecks.bluebook "Bluebook" do
       member keyword: "transition",      context: "Lifecycle", at: "1", named: "",     kind: "pairs", required: "true",  fills: "", pair_key_fills: "command", pair_value_fills: "to_state", pairs_shape: "fields"
       member keyword: "transition",      context: "Lifecycle", at: "",  named: "from", kind: "text",  required: "false", fills: "from_state"
       member keyword: "transition",      context: "Lifecycle", at: "",  named: "from", kind: "list",  required: "false", fills: "from_state"
+      member keyword: "mark",            context: "Lifecycle", at: "1", named: "",     kind: "symbol", required: "true",  fills: "name"
+      member keyword: "mark",            context: "Lifecycle", at: "2", named: "",     kind: "text",   required: "true",  fills: "state", variadic: "true"
 
     end
   end

data/lib/hecks/language/bluebook/bluebook.behaviors

@@ -0,0 +1,23 @@
+Hecks.behaviors "Bluebook" do
+  vision "A chapter is opened with a name, a vision and a classification, and refuses a classification the language does not admit."
+
+  loads "bluebook.bluebook", "bluebook.hecksagon"
+
+  test "Declare opens a chapter" do
+    tests "Declare", on: "Bluebook"
+    input name: "Pizzas", vision: "Pizzas, built and sold.", classification: "core"
+    expect emits: ["ChapterDeclared"]
+  end
+
+  test "Declare refuses a classification that is not core, supporting or generic" do
+    tests "Declare", on: "Bluebook"
+    input name: "Pizzas", vision: "Pizzas, built and sold.", classification: "huge"
+    expect refused: "a chapter is core, supporting, or generic"
+  end
+
+  test "Declare refuses a chapter with no name" do
+    tests "Declare", on: "Bluebook"
+    input name: "", vision: "Pizzas, built and sold.", classification: "core"
+    expect refused: "a chapter is named"
+  end
+end

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

@@ -243,13 +243,24 @@ Hecks.bluebook "Bluebook", version: "1" do
       member keyword: "provides",        context: "Bluebook", at: "",  named: "add_name",    kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "confirm",     kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "unsubscribe", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "awaiting_confirmation", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "receives_issues", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "left", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "confirm_window", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "unsubscribe_window", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "webhook_tolerance", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "session_hold", kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "initiate",    kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "succeeded",   kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "failed",      kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "lapse_reason", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "holds_seat",  kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "send_issue",      kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "record_delivery", kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "schedule", kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "request", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "registered_at", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "frees_seat"   , kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "connect", kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "reconnect", kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "disconnect", kind: "text", required: "false", fills: "provides"
@@ -257,6 +268,10 @@ Hecks.bluebook "Bluebook", version: "1" do
       member keyword: "provides",        context: "Bluebook", at: "",  named: "resume", kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "enable", kind: "text", required: "false", fills: "provides"
       member keyword: "provides",        context: "Bluebook", at: "",  named: "disable", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "mark_sensitive", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "markings_for", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "key_for", kind: "text", required: "false", fills: "provides"
+      member keyword: "provides",        context: "Bluebook", at: "",  named: "shred", kind: "text", required: "false", fills: "provides"
       member keyword: "aggregate",       context: "Bluebook", at: "1", named: "",        kind: "text",     required: "true",  fills: "name"
       member keyword: "read_model", context: "Bluebook", at: "1", named: "", kind: "text", required: "true", fills: "name"
       member keyword: "policy",          context: "Bluebook", at: "1", named: "",        kind: "text",     required: "true",  fills: "name"

data/lib/hecks/language/bluebook/entity.bluebook

@@ -20,6 +20,7 @@ Hecks.bluebook "Bluebook" do
     attribute :state_field, EntityText, optional: true
     attribute :state_start, EntityText, optional: true
     attribute :transitions, list_of(PieceTransition)
+    attribute :marks,       list_of(PieceMark)
 
     value_object "EntityName" do
       attribute :value, String
@@ -60,6 +61,11 @@ Hecks.bluebook "Bluebook" do
       attribute :to_state,   String
     end
 
+    value_object "PieceMark" do
+      attribute :name,  String
+      attribute :state, String
+    end
+
     # Declaration order is a fact about the source, so the language holds it, not the store.
     value_object "Position" do
       attribute :value, Integer
@@ -233,6 +239,18 @@ Hecks.bluebook "Bluebook" do
       emits PieceTransitionAttached
     end
 
+    command "Mark" do
+      role "Language"
+      goal "Attach one state to a named meaning of the entity's state machine"
+
+      attribute :name,  EntityText
+      attribute :state, EntityText
+
+      sets :marks, append: { name: :name, state: :state }
+
+      emits PieceMarkAttached
+    end
+
     # Keyword rows for this chapter; SyntaxBoot discovers aggregate-local seed tables.
     value_object "KeywordSeed" do
       attribute :word,          String

data/lib/hecks/language/bluebook/policy.behaviors

@@ -0,0 +1,19 @@
+Hecks.behaviors "Bluebook" do
+  vision "A policy hangs off a chapter and names the event it watches; an unnamed policy is refused."
+
+  loads "bluebook.bluebook", "policy.bluebook", "bluebook.hecksagon"
+
+  test "Declare puts a policy on a chapter" do
+    tests "Declare", on: "Policy"
+    setup  "Bluebook::Bluebook.Declare", name: "Pizzas", vision: "Pizzas, built and sold.", classification: "core"
+    input  bluebook: "Pizzas", name: "NotifyKitchen", on_event: "OrderPlaced"
+    expect emits: ["ReactionDeclared"]
+  end
+
+  test "Declare refuses a policy with no name" do
+    tests "Declare", on: "Policy"
+    setup  "Bluebook::Bluebook.Declare", name: "Pizzas", vision: "Pizzas, built and sold.", classification: "core"
+    input  bluebook: "Pizzas", name: "", on_event: "OrderPlaced"
+    expect refused: "a policy is named"
+  end
+end

data/lib/hecks/language/bluebook/policy.bluebook

@@ -13,6 +13,9 @@ Hecks.bluebook "Bluebook" do
     attribute :aggregate,       PolicyText
     attribute :on_event,        PolicyText
     attribute :trigger_command, PolicyText
+    # The need an `ask` names in the domain's own words, resolved at boot against the hecksagon's
+    # declared asks. Present in place of a port-naming `trigger_command`; empty otherwise.
+    attribute :ask,             PolicyText, optional: true
     attribute :target_domain,   PolicyText
     # An `across` target this domain expects never to reach. ModelCheck treats the related findings
     # as expected, and fails a declaration whose target turns out to be known after all.
@@ -63,7 +66,8 @@ Hecks.bluebook "Bluebook" do
       attribute :name,            PolicyName
       attribute :aggregate,       PolicyText, optional: true
       attribute :on_event,        PolicyText
-      attribute :trigger_command, PolicyText
+      attribute :trigger_command, PolicyText, optional: true
+      attribute :ask,             PolicyText, optional: true
       attribute :target_domain,   PolicyText, optional: true
       attribute :expect_undelivered, PolicyText, optional: true
       attribute :where,           PolicyText, optional: true
@@ -75,6 +79,7 @@ Hecks.bluebook "Bluebook" do
       sets :aggregate
       sets :on_event
       sets :trigger_command
+      sets :ask
       sets :target_domain
       sets :expect_undelivered
       sets :where
@@ -111,6 +116,7 @@ Hecks.bluebook "Bluebook" do
 
       member word: "on",              context: "Policy",    body: "none", inner: "", opens: "",       fills: "on_event", calls: "on_impl"
       member word: "trigger",         context: "Policy",    body: "none", inner: "", opens: "",       fills: "trigger_command", calls: "trigger_impl"
+      member word: "ask",             context: "Policy",    body: "none", inner: "", opens: "",       fills: "ask", calls: "ask_impl"
       member word: "across",          context: "Policy",    body: "none", inner: "", opens: "",       fills: "target_domain", calls: "across_impl"
       member word: "where",           context: "Policy",    body: "source", inner: "", opens: "", fills: "where"
       member word: "for_each",        context: "Policy",    body: "none", inner: "", opens: "", fills: "for_each"
@@ -138,10 +144,12 @@ Hecks.bluebook "Bluebook" do
       member keyword: "on",              context: "Policy", at: "1", named: "", kind: "text",     required: "true", fills: "on_event"
       member keyword: "trigger",         context: "Policy", at: "1", named: "", kind: "constant", required: "true", fills: "trigger_command"
       member keyword: "trigger",         context: "Policy", at: "1", named: "", kind: "text",     required: "true", fills: "trigger_command"
+      member keyword: "ask",             context: "Policy", at: "1", named: "", kind: "symbol", required: "true", fills: "ask"
       member keyword: "across",          context: "Policy", at: "1", named: "", kind: "text", required: "true", fills: "target_domain"
       member keyword: "across",          context: "Policy", at: "", named: "expect_undelivered", kind: "flag", required: "false", fills: "expect_undelivered"
       member keyword: "for_each",        context: "Policy", at: "1", named: "", kind: "text", required: "true", fills: "for_each"
       member keyword: "trigger", context: "Policy", at: "", named: "with", kind: "pairs", required: "false", fills: "with_spec", pairs_shape: "verbatim"
+      member keyword: "ask",     context: "Policy", at: "", named: "with", kind: "pairs", required: "false", fills: "with_spec", pairs_shape: "verbatim"
 
     end
   end

data/lib/hecks/language/bluebook/query.bluebook

@@ -121,7 +121,7 @@ Hecks.bluebook "Bluebook" do
       goal "Attach one where-clause to the query"
 
       attribute :field, QueryText
-      # The same word at the same door — see Command.Change.op.
+      # The same word at the same entry point — see Command.Change.op.
       attribute :op,    QueryText, admits: "Vocabulary::QueryComparator"
       attribute :value, QueryText
 

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

@@ -611,6 +611,10 @@ Hecks.bluebook "Bluebook" do
     # `mode` is how `pattern` (an extended regex over changed paths) decides:
     # `touches` runs the job when any changed path matches, `skips_unless` runs it
     # when any changed path does NOT match (the pattern is the safe-to-skip list).
+    # `release_only` answers a different question and ignores `pattern`: `touched` is false only
+    # when the change edits nothing but the `ReleaseFile` rows' files and lines and the base it is
+    # measured against has every inheritable `RequiredCheck` green (ADR 0107), so the run may
+    # inherit that certification.
     # `push` is what a push event does: `skip` leaves the gate out of push runs,
     # `before_sha` diffs against the push's `before` commit.
     value_object "CiGate" do
@@ -624,19 +628,44 @@ Hecks.bluebook "Bluebook" do
       member name: "runtime_changed", workflow: "ci.yml", mode: "touches",
              pattern: '^lib/hecks/runtime/', push: "before_sha",
              label: "does this change touch lib/hecks/runtime/**?"
+      member name: "release_only", workflow: "ci.yml", mode: "release_only",
+             pattern: "", push: "before_sha",
+             label: "is this change only a release bump on a certified base?"
       member name: "postgres_io_relevant_changed", workflow: "ci-postgres-io-parallel.yml", mode: "skips_unless",
              pattern: '^(docs/|editors/|release/|deploy/|\.claude/|\.githooks/|rust/(parser|codegen|host|build|lsp|web|tests)/|\.rubocop\.yml$|\.rubocop_todo\.yml$|\.mcp\.json$|\.rspec-local\.example$|README\.md$|CHANGELOG\.md$|CONTRIBUTING\.md$|SECURITY\.md$|LICENSE$|\.gitignore$)',
              push: "skip",
              label: "does this change touch anything rspec_postgres_io_parallel covers?"
     end
 
+    # The files a release bump edits, and the lines of each it may change. A commit whose whole
+    # diff against a certified base falls inside these rows inherits the base's certification
+    # (`CiGate` `release_only`, ADR 0107): its checks report success without their jobs running,
+    # and the `release_consistency` check still runs on it. `path` is the file, exact; `lines` is
+    # an extended regex every added or removed line of that file must match, empty for any line.
+    value_object "ReleaseFile" do
+      attribute :path,  String
+      attribute :lines, String
+
+      member path: "lib/hecks/version.rb", lines: "^\\s*VERSION = \"[0-9]+\\.[0-9]+\\.[0-9]+\"\\.freeze$"
+      member path: "CHANGELOG.md", lines: ""
+      member path: "README.md", lines: "^(\\*\\*Status:\\*\\* )?Current release: `[0-9]+\\.[0-9]+\\.[0-9]+`"
+      member path: "Gemfile.lock", lines: "^    hecks \\([0-9]+\\.[0-9]+\\.[0-9]+\\)$"
+      member path: "rust/host/HECKS_RELEASE", lines: "^[0-9]+\\.[0-9]+\\.[0-9]+$"
+      member path: "packages/hecks-client/package.json", lines: "^\\s*\"version\": \"[0-9]+\\.[0-9]+\\.[0-9]+\",?$"
+      member path: "packages/hecks-client/package-lock.json", lines: "^\\s*\"version\": \"[0-9]+\\.[0-9]+\\.[0-9]+\",?$"
+    end
+
     # The checks a commit must have passed before a `Promotion` moves it onto a guarded lane. Each
     # is the name of a job in .github/workflows that reports to a commit as a check run; a check
     # that a path gate skipped reports `skipped`, which counts as passed. `hecks promote` reads
     # these rows, and hecks project_lanes writes them into the ruleset of any lane that requires
     # them, so the list lives here and nowhere else.
+    #
+    # `runs` is `always` for a check a release bump still runs (it is not inherited from the base);
+    # empty for a check a bump may inherit.
     value_object "RequiredCheck" do
       attribute :name, String
+      attribute :runs, String
 
       member name: "rspec"
       member name: "checks"
@@ -647,6 +676,7 @@ Hecks.bluebook "Bluebook" do
       member name: "rspec_rust_codegen"
       member name: "rspec_rust_host"
       member name: "rspec_fuzzing"
+      member name: "release_consistency", runs: "always"
     end
 
     # The branches a change travels along. `main` takes pushes with no gate; `stable` takes only
@@ -660,6 +690,10 @@ Hecks.bluebook "Bluebook" do
     # empty when none does; `follows` is the lane a promotion draws from, or empty. `alert_after`
     # is the whole hours the lane may stand behind the lane it follows before `hecks
     # promotion_run.watch` files a finding, or empty for a lane that is never late.
+    # `release_trailer` is the commit-message trailer a commit that sets the version must carry
+    # (`Release-Approved-By: <name>`) before a release is cut from this lane, or empty for a lane
+    # nothing is released from: the owner decides when a release happens by writing that line in
+    # the bump commit, and `release.yml` and `publishing_run.publish` both refuse a bump without it.
     value_object "Lane" do
       attribute :name,        String
       attribute :guarded,     String
@@ -667,9 +701,34 @@ Hecks.bluebook "Bluebook" do
       attribute :feeds,       String
       attribute :follows,     String
       attribute :alert_after, String
+      attribute :release_trailer, String
 
-      member name: "main",   guarded: "no",  pushers: "anyone", feeds: "",     follows: "",     alert_after: ""
-      member name: "stable", guarded: "yes", pushers: "green",  feeds: "edge", follows: "main", alert_after: "4"
+      member name: "main",   guarded: "no",  pushers: "anyone", feeds: "",     follows: "",     alert_after: "",
+             release_trailer: ""
+      member name: "stable", guarded: "yes", pushers: "green",  feeds: "edge", follows: "main", alert_after: "4",
+             release_trailer: "Release-Approved-By"
+    end
+
+    # A binary hecks builds once per change to its crate and publishes, so a client that needs the
+    # same binary downloads it instead of compiling it (ADR 0110). `hecks regeneration_run.project_lanes`
+    # writes .github/workflows/publish-<name>.yml from each row; `Hecks::RustBuild::PrebuiltBinary`
+    # reads the same rows to name what to download.
+    #
+    # `crate` is the directory under the checkout that is built and keyed: the key is a hash of every
+    # file in it that goes into the build, so the same bytes in the crate are the same release.
+    # `executable` is the Cargo binary and `target` the Rust triple it is built for. `runner` is the
+    # GitHub-hosted image it is built on, pinned (never `-latest`) because a binary links the
+    # runner's glibc and must run on every host that runs that image or a newer one.
+    # The release is tagged `<name>-<key>` and carries `<executable>-<target>` and its `.sha256`.
+    value_object "PrebuiltBinary" do
+      attribute :name,   String
+      attribute :crate,  String
+      attribute :executable, String
+      attribute :target, String
+      attribute :runner, String
+
+      member name: "host", crate: "rust/host", executable: "bootstrap", target: "x86_64-unknown-linux-gnu",
+             runner: "ubuntu-24.04"
     end
 
     # The dials of the hecks_qa loop: what each is called, the type of value it takes and what it
@@ -791,8 +850,8 @@ Hecks.bluebook "Bluebook" do
       member script: "compact", section: "Custodian", aggregate: "Era", verb: "compact"
       member script: "heki_compact", section: "Custodian", aggregate: "Era", verb: "compact_heki"
       member script: "vendor_bluebook", section: "Custodian", aggregate: "Package", verb: "vendor", note: "waits: a refusal exits 1 with its reason on stderr"
-      member script: "project_cli", section: "Custodian", aggregate: "Door", verb: "project_cli"
-      member script: "hecks_mcp_door", section: "Custodian", aggregate: "Door", verb: "serve_mcp"
+      member script: "project_cli", section: "Custodian", aggregate: "Launch", verb: "project_cli"
+      member script: "hecks_mcp_door", section: "Custodian", aggregate: "Launch", verb: "serve_mcp"
       member script: "project_rust", section: "Custodian", aggregate: "Build", verb: "project_rust"
       member script: "project_wasm", section: "Custodian", aggregate: "Build", verb: "build_wasm"
       member script: "project_host", section: "Custodian", aggregate: "Build", verb: "build_host"

data/lib/hecks/language/hecksagon/domain_port.bluebook

@@ -1,6 +1,6 @@
 Hecks.bluebook "Hecksagon" do
   aggregate "DomainPort" do
-    description "A primary port — the boundary between a domain and its adapters, in hexagonal terms, is exactly what a hecksagon already IS for every other port. Root-level (belongs to the chapter) or aggregate-scoped (reached the same way persisted_by is, through the open Const.verb(...) door). One of two shapes, never both: a list of operations translating an inbound fact into this domain's own events, or a bare verb naming a swappable resource port (the same Hecks.port a project's own .port file declares, reached from inside the hecksagon instead)."
+    description "A primary port — the boundary between a domain and its adapters, in hexagonal terms, is exactly what a hecksagon already IS for every other port. Root-level (belongs to the chapter) or aggregate-scoped (reached the same way persisted_by is, through the open Const.verb(...) entry point). One of two shapes, never both: a list of operations translating an inbound fact into this domain's own events, or a bare verb naming a swappable resource port (the same Hecks.port a project's own .port file declares, reached from inside the hecksagon instead)."
 
     identified_by PortName, as: :name
 

data/lib/hecks/language/hecksagon/hecksagon.bluebook

@@ -6,6 +6,7 @@ Hecks.bluebook "Hecksagon" do
 
     attribute :subscriptions,      list_of(Subscription)
     attribute :attachments,        list_of(Attachment)
+    attribute :driving,            list_of(DrivingAdapter)
 
     value_object "HecksagonName" do
       attribute :value, String
@@ -27,6 +28,14 @@ Hecks.bluebook "Hecksagon" do
       invariant("an attachment comes from the gem or from vendor") { source == "gem" || source == "vendor" }
     end
 
+    # A driving adapter this hecksagon admits: `value` names one of `Ruby`, `Cli`, `Json` or `Mcp`.
+    # A domain that declares none is open to all of them; one that declares any is reached through
+    # those and refused by the rest.
+    value_object "DrivingAdapter" do
+      attribute :value, String
+      invariant("a driving adapter is named") { !value.to_s.empty? }
+    end
+
     # The name an attachment is asked for by, before its source is known.
     value_object "ChapterName" do
       attribute :value, String
@@ -67,6 +76,17 @@ Hecks.bluebook "Hecksagon" do
       emits "ChapterAttached"
     end
 
+    command "DrivenBy" do
+      role "Deployment"
+      goal "Admit a driving adapter to reach this hecksagon's domain; adapters left out refuse it"
+
+      attribute :adapter, DrivingAdapter
+
+      sets :driving, append: { value: :adapter }
+
+      emits "DrivingAdapterAdmitted"
+    end
+
     # Keyword rows for File and Hecksagon; SyntaxBoot discovers every aggregate-local seed table.
     value_object "KeywordSeed" do
       attribute :word,          String
@@ -83,6 +103,7 @@ Hecks.bluebook "Hecksagon" do
       member word: "hecksagon",       context: "File",     body: "keywords", inner: "Hecksagon",      opens: "Hecksagon",      fills: ""
       member word: "subscribe",       context: "Hecksagon", body: "none", inner: "", opens: "", fills: "subscriptions"
       member word: "attaches",        context: "Hecksagon", body: "none", inner: "", opens: "", fills: "attachments"
+      member word: "driven_by",       context: "Hecksagon", body: "none", inner: "", opens: "", fills: "driving"
       member word: "port",            context: "Hecksagon",     body: "keywords", inner: "DomainPort",    opens: "DomainPort",    fills: "", calls: "port_impl"
       # A cross-domain reaction wired here rather than in the bluebook; reuses the Policy context.
       # No `calls:` — HecksagonBuilder#translates is an ordinary method, found before `word_gate`.
@@ -113,6 +134,7 @@ Hecks.bluebook "Hecksagon" do
       member keyword: "subscribe",       context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "subscriptions"
       member keyword: "attaches",        context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "attachments"
       member keyword: "attaches",        context: "Hecksagon", at: "",  named: "from", kind: "symbol", required: "false", fills: "source"
+      member keyword: "driven_by",       context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "driving"
       member keyword: "port",            context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "name"
       member keyword: "translates",      context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "name"
 

data/lib/hecks/language/oidc.json

@@ -31,6 +31,11 @@
       "verb": "Bluebook::Aggregate.Lifecycle",
       "role": "Language"
     },
+    {
+      "scope": "bluebook:aggregate.mark",
+      "verb": "Bluebook::Aggregate.Mark",
+      "role": "Language"
+    },
     {
       "scope": "bluebook:aggregate.precondition",
       "verb": "Bluebook::Aggregate.Precondition",
@@ -156,6 +161,11 @@
       "verb": "Bluebook::Entity.Lifecycle",
       "role": "Language"
     },
+    {
+      "scope": "bluebook:entity.mark",
+      "verb": "Bluebook::Entity.Mark",
+      "role": "Language"
+    },
     {
       "scope": "bluebook:entity.precondition",
       "verb": "Bluebook::Entity.Precondition",

data/lib/hecks/language/port.bluebook

@@ -1,9 +1,9 @@
 Hecks.bluebook "Port" do
-  vision "The .port language, declared in itself. A port names one resource door a domain's own aggregates call by verb — persisted_by, posted_by, whatever a chapter spells — bound to a real driven adapter at the world level. A sibling artifact to the bluebook, not part of one: the same port name is reused across every domain that needs the same kind of door."
+  vision "The .port language, declared in itself. A port names one resource a domain's own aggregates call by verb — persisted_by, posted_by, whatever a chapter spells — bound to a real driven adapter at the world level. A sibling artifact to the bluebook, not part of one: the same port name is reused across every domain that needs the same kind of entry point."
   core
 
   aggregate "Port" do
-    description "One .port — a resource door a domain's own aggregates call by verb, and whether calling it answers with a value (reply) or fires an effect with nothing to hand back (effect)."
+    description "One .port — a resource a domain's own aggregates call by verb, and whether calling it answers with a value (reply) or fires an effect with nothing to hand back (effect)."
 
     identified_by PortName, as: :name
 
@@ -25,7 +25,7 @@ Hecks.bluebook "Port" do
       attribute :value, String, one_of: ["reply", "effect"]
     end
 
-    # The method contract: what an adapter must `respond_to?` for a dispatch through this door.
+    # The method contract: what an adapter must `respond_to?` for a dispatch through this port.
     # A port that declares none is unchecked beyond `verify!`.
     value_object "PortAnswer" do
       attribute :value, String
@@ -34,7 +34,7 @@ Hecks.bluebook "Port" do
 
     command "Declare" do
       role "Deployment"
-      goal "Open a resource door a domain's own aggregates may call by verb"
+      goal "Open a resource a domain's own aggregates may call by verb"
 
       attribute :name,   PortName
       # Optional: a port may declare only `signal`; `verb` has no default, unlike `signal`.

data/lib/hecks/literal.rb

@@ -7,6 +7,14 @@ module Hecks
     def to_s = "state(:#{name})"
   end
 
+  # A mutation source computed from arithmetic over command arguments, state and numbers:
+  # `sets :refund, to: paid * rate / 100`. `text` is the canonical expression, read by
+  # `Bluebook::Expression::Resolver`; its operands name command arguments first, then the
+  # record's own fields.
+  Computed = Struct.new(:text) do
+    def to_s = "expr(#{text})"
+  end
+
   # The one wire spelling for a Ruby literal captured from a bluebook: a symbol wears its
   # colon, a string its quotes, a hash `{key: value}`, a list brackets; the rest are bare.
   # Stated here, not left to `inspect`, whose Hash rendering differs between Ruby 3.3 and 3.4.
@@ -15,7 +23,7 @@ module Hecks
 
     # Turns a Ruby value into its self-describing wire spelling.
     #
-    # @param value [Object] value to render: nil, Symbol, String, StateRef, true,
+    # @param value [Object] value to render: nil, Symbol, String, StateRef, Computed, true,
     #   false, Integer, Float, Hash, or Array (recursively)
     # @return [String] the self-describing spelling `read` can parse back
     # @raise [ArgumentError] if `value` is a type with no pinned literal spelling
@@ -24,7 +32,7 @@ module Hecks
       when nil    then "nil"
       when Symbol then ":#{value}"
       when String then quote(value)
-      when StateRef, true, false, Integer, Float then value.to_s
+      when StateRef, Computed, true, false, Integer, Float then value.to_s
       when Hash, Array then render_collection(value)
       else
         raise ArgumentError, "#{value.class} has no pinned literal spelling — teach Literal.render one " \
@@ -44,7 +52,7 @@ module Hecks
     # A bare word stays a String, since some fields are stored as plain text, never rendered.
     #
     # @param text [String, #to_s] wire spelling produced by `render`, or a bare word
-    # @return [Object] nil, true, false, Integer, Float, Symbol, StateRef, String,
+    # @return [Object] nil, true, false, Integer, Float, Symbol, StateRef, Computed, String,
     #   Hash, or Array — or `text` itself, stripped, when it matches no known spelling
     def read(text)
       raw = text.to_s.strip
@@ -65,6 +73,7 @@ module Hecks
       [->(raw) { raw.match?(/\A-?\d+\.\d+\z/) }, :to_f.to_proc],
       [->(raw) { raw.start_with?(":") }, ->(raw) { raw[1..].to_sym }],
       [->(raw) { raw.match?(/\Astate\(:[A-Za-z_][A-Za-z0-9_]*\)\z/) }, ->(raw) { StateRef.new(raw[7..-2].to_sym) }],
+      [->(raw) { raw.match?(/\Aexpr\(.+\)\z/m) }, ->(raw) { Computed.new(raw[5..-2]) }],
       [->(raw) { quoted?(raw) }, ->(raw) { unquote(raw) }],
       [->(raw) { raw.start_with?("{") && raw.end_with?("}") }, ->(raw) { read_hash(raw) }],
       [->(raw) { raw.start_with?("[") && raw.end_with?("]") }, ->(raw) { read_array(raw) }]

data/lib/hecks/ports/key_vault.rb

@@ -20,12 +20,17 @@ module Hecks
       # reverse, so Shred cannot be dispatched before the key is actually gone. Idempotent:
       # a subject with no live key, or one already shredded, is left alone and returns false.
       def shred!(dispatcher, domain:, subject_id:) # rubocop:disable Naming/PredicateMethod
-        record = dispatcher.query("Privacy::SubjectKey.ForSubject", domain: domain, subject_id: subject_id).first
+        provider = dispatcher.registry.provider_of(Bluebook::Capabilities::SUBJECT_KEYS)
+        return false unless provider
+
+        record = dispatcher.query(provider.provided_verb(Bluebook::Capabilities::SUBJECT_KEYS, :key_for),
+                                  domain: domain, subject_id: subject_id).first
         return false unless record
         return false if record[:status].to_s == "shredded"
 
         destroy(dispatcher.registry, key_reference: record[:key_reference].value)
-        dispatcher.dispatch_flat("Privacy::SubjectKey.Shred", domain: { value: domain }, subject_id: { value: subject_id })
+        shred = provider.provided_verb(Bluebook::Capabilities::SUBJECT_KEYS, :shred)
+        dispatcher.dispatch_flat(shred, domain: { value: domain }, subject_id: { value: subject_id })
         true
       end