hecks 3.14.0 → 4.0.0

data/lib/hecks/language/translation/translation_aggregate.bluebook

@@ -29,7 +29,7 @@ Hecks.bluebook "Translation" do
     attribute :converts,  list_of(TranslationConvert)
     attribute :drops,     list_of(TranslationName)
     attribute :retypes,   list_of(TranslationRetype)
-    attribute :computes,  list_of(TranslationCompute)
+    attribute :derives,   list_of(TranslationDerive)
     attribute :rekeys,    list_of(TranslationRekey)
     attribute :backfills, list_of(TranslationBackfill)
 
@@ -56,14 +56,13 @@ Hecks.bluebook "Translation" do
       attribute :to,   TranslationName
     end
 
-    value_object "TranslationCompute" do
-      attribute :from, TranslationName
-      attribute :to,   TranslationName
-      attribute :sql,  TranslationLiteralText
+    value_object "TranslationDerive" do
+      attribute :to,         TranslationName
+      attribute :expression, TranslationLiteralText
     end
 
     value_object "TranslationRekey" do
-      attribute :sql, TranslationLiteralText
+      attribute :to, TranslationName
     end
 
     value_object "TranslationBackfill" do
@@ -146,28 +145,27 @@ Hecks.bluebook "Translation" do
       emits "TranslationRetypeAdded"
     end
 
-    command "AddCompute" do
+    command "AddDerive" do
       role "Deployment"
-      goal "Move data at an old path to a new one, transformed by a real SQL expression"
+      goal "Give a new field a value computed from the record's own text, read before any other rule runs"
 
-      attribute :from, TranslationName
-      attribute :to,   TranslationName
-      attribute :sql,  TranslationLiteralText
+      attribute :to,         TranslationName
+      attribute :expression, TranslationLiteralText
 
-      sets :computes, append: { from: :from, to: :to, sql: :sql }
+      sets :derives, append: { to: :to, expression: :expression }
 
-      emits "TranslationComputeAdded"
+      emits "TranslationDeriveAdded"
     end
 
-    command "AddRekey" do
+    command "AddRekeyTo" do
       role "Deployment"
-      goal "Recompute this aggregate's own identity by a real SQL expression"
+      goal "Take this aggregate's identity from the value of a field a derive computes"
 
-      attribute :sql, TranslationLiteralText
+      attribute :to, TranslationName
 
-      sets :rekeys, append: { sql: :sql }
+      sets :rekeys, append: { to: :to }
 
-      emits "TranslationRekeyAdded"
+      emits "TranslationRekeyToAdded"
     end
 
     command "AddBackfill" do
@@ -200,8 +198,8 @@ Hecks.bluebook "Translation" do
       member word: "convert",         context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "converts", calls: "convert_impl"
       member word: "drop",            context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "drops"
       member word: "retype",          context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "retypes", calls: "retype_impl"
-      member word: "compute",         context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "computes", calls: "compute_impl"
-      member word: "rekey",           context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "rekeys", calls: "rekey_impl"
+      member word: "derive",          context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "derives", calls: "derive_impl"
+      member word: "rekey_to",        context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "rekeys", calls: "rekey_to_impl"
       member word: "backfill",        context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "backfills", calls: "backfill_impl"
       member word: "unresolved",      context: "TranslationAggregate", body: "none", inner: "", opens: "", fills: "", calls: "unresolved_impl"
 
@@ -234,10 +232,9 @@ Hecks.bluebook "Translation" do
       member keyword: "drop",            context: "TranslationAggregate", at: "1", named: "",       kind: "symbol",  required: "true", fills: "name", blank_message: "a drop needs a name"
       member keyword: "retype",          context: "TranslationAggregate", at: "1", named: "",       kind: "text",    required: "true", fills: "old_type"
       member keyword: "retype",          context: "TranslationAggregate", at: "",  named: "to", kind: "text", required: "true", fills: "to"
-      member keyword: "compute",         context: "TranslationAggregate", at: "1", named: "", kind: "text", required: "true", fills: "old_path"
-      member keyword: "compute",         context: "TranslationAggregate", at: "",  named: "to",      kind: "text",    required: "true", fills: "to"
-      member keyword: "compute",         context: "TranslationAggregate", at: "",  named: "sql",     kind: "text",    required: "true", fills: "sql"
-      member keyword: "rekey",           context: "TranslationAggregate", at: "",  named: "sql",     kind: "text",    required: "true", fills: "sql"
+      member keyword: "derive",          context: "TranslationAggregate", at: "1", named: "",   kind: "text", required: "true", fills: "to"
+      member keyword: "derive",          context: "TranslationAggregate", at: "",  named: "as", kind: "text", required: "true", fills: "as"
+      member keyword: "rekey_to",        context: "TranslationAggregate", at: "1", named: "", kind: "symbol", required: "true", fills: "to"
       member keyword: "backfill",        context: "TranslationAggregate", at: "1", named: "", kind: "symbol", required: "true", fills: "name"
       member keyword: "backfill",        context: "TranslationAggregate", at: "",  named: "default", kind: "literal", required: "true", fills: "default"
       member keyword: "unresolved",      context: "TranslationAggregate", at: "1", named: "", kind: "symbol", required: "true", fills: "name"

data/lib/hecks/ports/access_control.rb

@@ -26,8 +26,8 @@ module Hecks
 
       # Admits a new person, in whatever way this domain's adapter defines admission.
       #
-      # The keywords carry the names of a verified sign-in (`Ports::Authentication.verify`),
-      # but nothing here wires the two together, so their shapes are adapter-defined.
+      # The keywords carry the names of a verified OIDC sign-in, but nothing here wires
+      # one to this port, so their shapes are adapter-defined.
       #
       # @param registry [Runtime::Registry] the booted registry to resolve the adapter against
       # @param email [Object] adapter-defined, forwarded unchanged; the person's email

data/lib/hecks/ports/persistence/plugins/era/era_check.rb

@@ -14,7 +14,7 @@ module Hecks
     module EraCheck
       module_function
 
-      # Runs both halves of the era gate over every bluebook in a registry.
+      # Runs the era gate over every bluebook in a registry.
       #
       # Looks up each bluebook's own source separately: `attaches` can share a boot between
       # the domain's own bluebook and a differently-sourced one, so one file read once and reused
@@ -23,27 +23,12 @@ module Hecks
       # @param registry [Runtime::Registry] the registry being booted
       # @param directory [String] the domain's bluebook directory, searched for each source
       # @return [void]
-      # @raise [Runtime::WiringError] if a compute rule is bound to a non-lineage-capable adapter,
-      #   a persistence binding cannot be resolved, a lineage-bound bluebook has no findable
-      #   source, or `era_check!` refuses the boot
+      # @raise [Runtime::WiringError] if a persistence binding cannot be resolved, a lineage-bound
+      #   bluebook has no findable source, or `era_check!` refuses the boot
       def check!(registry, directory)
-        check_compute_rules_for_registry!(registry)
         check_lineage!(registry, directory)
       end
 
-      # Refuses the boot when any bluebook's compute rule is bound away from Postgres.
-      #
-      # Runs unconditionally for every registry, unlike check_lineage!'s
-      # capability-gated pass below (ADR 0031).
-      #
-      # @param registry [Runtime::Registry] the registry whose bluebooks are all checked
-      # @return [void]
-      # @raise [Runtime::WiringError] if an aggregate carrying a compute rule is bound to an
-      #   adapter that is not lineage-capable, or its persistence binding cannot be resolved
-      def check_compute_rules_for_registry!(registry)
-        registry.bluebooks.each_value { |bluebook| check_compute_rules!(registry, bluebook) }
-      end
-
       # Hands every bluebook, with its own source text, to its adapter's era check.
       #
       # Capability-gated (ADR 0031): check_bluebook! below still returns
@@ -222,29 +207,6 @@ module Hecks
               "it could be found (checked #{directory.inspect} and the framework registry)"
       end
 
-      # Refuses the boot when one bluebook's compute rule is bound away from Postgres.
-      #
-      # A compute rule's SQL is its only implementation, so it cannot
-      # boot on any adapter but Postgres, independent of shape checks.
-      #
-      # @param registry [Runtime::Registry] the registry holding the declared translations
-      #   and the aggregate's bindings
-      # @param bluebook [Bluebook::Chapter] the bluebook whose aggregates are checked
-      # @return [void]
-      # @raise [Runtime::WiringError] if an aggregate carrying a compute rule is bound to an
-      #   adapter that is not lineage-capable, or its persistence binding cannot be resolved
-      def check_compute_rules!(registry, bluebook)
-        bluebook.aggregates.each do |aggregate|
-          lineage = Ports::Persistence::Lineage.for(registry, bluebook.name, aggregate)
-          next unless lineage&.computes?
-
-          adapter = adapter_for(registry, bluebook.name, aggregate)
-          next if lineage_capable?(registry, adapter)
-
-          raise WiringError, "compute rules require the Postgres adapter; #{aggregate.name} is bound to #{adapter}"
-        end
-      end
-
       # Names the adapter an aggregate's authoritative persistence bind points at.
       #
       # @param registry [Runtime::Registry] the registry holding the domain's hecksagon

data/lib/hecks/ports/persistence/plugins/era/lineage/coverage.rb

@@ -12,7 +12,7 @@ module Hecks
           # attribute that is new outright, never a path that existed and moved.
           #
           # @param path [String, Symbol] a bare attribute name or a dotted value-object member path
-          # @return [Boolean] true when a rename, move, convert, drop or compute names the path or
+          # @return [Boolean] true when a rename, move, convert, or drop names the path or
           #   its top-level attribute as its source, or a backfill names the top-level attribute
           def explains?(path)
             path = path.to_s
@@ -30,8 +30,8 @@ module Hecks
           # the same way a backfill would.
           #
           # @param path [String, Symbol] the name of a top-level attribute new in the current shape
-          # @return [Boolean] true when a rename, move, convert or compute lands a value in that
-          #   attribute, or a backfill names it
+          # @return [Boolean] true when a rename, move, convert or derive lands a value in
+          #   that attribute, or a backfill names it
           def fills?(path)
             path = path.to_s
 
@@ -42,13 +42,13 @@ module Hecks
 
           private
 
-          # Every path a move, convert, compute or drop reads from.
+          # Every path a move, convert or drop reads from.
           def sources
-            [*@moves, *@converts, *@rules.computes].map(&:from) + @drops.map(&:to_s)
+            [*@moves, *@converts].map(&:from) + @drops.map(&:to_s)
           end
 
-          # Every path a move, convert or compute writes to.
-          def destinations = [*@moves, *@converts, *@rules.computes].map(&:to)
+          # Every path a move, convert or derive writes to.
+          def destinations = [*@moves, *@converts, *@rules.derives].map(&:to)
 
           def backfilled?(name) = @rules.backfills.any? { |backfill| backfill.name.to_s == name }
         end

data/lib/hecks/ports/persistence/plugins/era/lineage/rewrite.rb

@@ -2,12 +2,13 @@ module Hecks
   module Ports
     module Persistence
       class Lineage
-        # The reference semantics of rename, move, convert, drop and backfill, applied in that
-        # order to a deep copy of one entry's state.
+        # The reference semantics of derive, rename, move, convert, drop and backfill, applied in
+        # that order to a deep copy of one entry's state.
         module Rewrite
           private
 
           def rewrite(state)
+            apply_derives(state)
             apply_renames(state, @renames)
             @moves.each { |move| apply_move(state, move) }
             @converts.each { |convert| apply_convert(state, convert) }
@@ -17,6 +18,28 @@ module Hecks
             state
           end
 
+          # Every derive reads the state as stored, so the values are all computed before the
+          # first is written; a derive with no value writes nothing.
+          def apply_derives(state)
+            computed = @rules.derives.map { |derive| [derive, Bluebook::TranslationExpression.evaluate(derive.tree, state)] }
+            computed.each do |derive, value|
+              next if value.nil?
+
+              top, member = derive.to.split(".", 2)
+              insert(state, top.to_sym, member, value, rule: "derive #{derive.to}")
+            end
+          end
+
+          # The id a `rekey_to` gives a record: the value of its derive, read from the stored state;
+          # the record keeps its id where the derive has no value or the edge has no `rekey_to`.
+          def rekeyed_id(entry)
+            rekey = @rules.rekeys.first
+            return entry.id unless rekey
+
+            derive = @rules.derives.find { |candidate| candidate.to == rekey.to }
+            Bluebook::TranslationExpression.evaluate(derive.tree, entry.state) || entry.id
+          end
+
           def deep_dup(node)
             case node
             when Hash then node.transform_values { |value| deep_dup(value) }

data/lib/hecks/ports/persistence/plugins/era/lineage/rules.rb

@@ -6,18 +6,18 @@ module Hecks
         # an unknown keyword raises ArgumentError.
         #
         # - `retypes` — type names meaning the same shape
-        # - `computes` — SQL-only rules, never applied in process
-        # - `rekeys` — SQL rewrites of identity; only the first is read
+        # - `derives` — new fields computed from the record's own text
+        # - `rekeys` - the field whose derived value becomes the id
         # - `backfills` — defaults for a new attribute
         # - `ancestor_name` — the aggregate's name before the edge, if renamed
         # - `ancestor_storage_name` — snake_case storage name of `ancestor_name`
-        Rules = Struct.new(:retypes, :computes, :rekeys, :backfills, :ancestor_name, :ancestor_storage_name,
+        Rules = Struct.new(:retypes, :derives, :rekeys, :backfills, :ancestor_name, :ancestor_storage_name,
                            keyword_init: true) do
           # Builds the rules with every list defaulting to empty.
           #
           # @param given [Hash] any of the members; an unknown key raises ArgumentError
           # @return [Rules]
-          def self.build(**given) = new(retypes: [], computes: [], rekeys: [], backfills: [], **given)
+          def self.build(**given) = new(retypes: [], derives: [], rekeys: [], backfills: [], **given)
         end
       end
     end

data/lib/hecks/ports/persistence/plugins/era/lineage.rb

@@ -59,17 +59,23 @@ module Hecks
           ancestor_storage_name = renamed_aggregate ? Naming.snake(declared.was) : nil
 
           new(declared.renames, declared.moves, declared.converts, declared.drops,
-              retypes: declared.retypes, computes: declared.computes, rekeys: declared.rekeys,
-              backfills: declared.backfills,
-              ancestor_name: ancestor_name, ancestor_storage_name: ancestor_storage_name)
+              **optional_rules(declared), ancestor_name: ancestor_name, ancestor_storage_name: ancestor_storage_name)
         end
 
+        # The rule lists an edge carries beyond renames, moves, converts and drops.
+        def self.optional_rules(declared)
+          { retypes: declared.retypes, derives: declared.derives,
+            rekeys: declared.rekeys, backfills: declared.backfills }
+        end
+        private_class_method :optional_rules
+
         # @param renames [Hash{Symbol => Symbol}] old attribute name to new name
         # @param moves [Array<Bluebook::TranslationMove>] from/to paths across a value object
         # @param converts [Array<Bluebook::TranslationConvert>] moves mapped through a values table
         # @param drops [Array<Symbol>] bare or dotted paths whose data is discarded
         # @param rules [Hash] the optional rule lists, as `Rules` names them: `retypes:`,
-        #   `computes:`, `rekeys:`, `backfills:`, `ancestor_name:` and `ancestor_storage_name:`
+        #   `derives:`, `rekeys:`, `backfills:`, `ancestor_name:` and
+        #   `ancestor_storage_name:`
         # @raise [ArgumentError] on a keyword `Rules` does not name
         def initialize(renames, moves = [], converts = [], drops = [], **rules)
           @renames = renames
@@ -79,14 +85,6 @@ module Hecks
           @rules = Rules.build(**rules)
         end
 
-        # Reports whether any rule in this edge is a compute.
-        #
-        # Compute has no in-process implementation; an aggregate carrying
-        # one refuses to boot anywhere but Postgres.
-        #
-        # @return [Boolean] true when the edge declares at least one compute rule
-        def computes? = !@rules.computes.empty?
-
         # Reports whether this edge rewrites the aggregate's identity.
         #
         # The single source of truth for this; other call sites ask here
@@ -95,23 +93,16 @@ module Hecks
         # @return [Boolean] true when the edge declares at least one rekey rule
         def rekey? = !@rules.rekeys.empty?
 
-        # Returns the SQL expression the edge's first rekey rule declares.
-        #
-        # Only the first rule is read, the same one-per-aggregate assumption
-        # `compute` makes; more than one is a DSL-level decision to arbitrate elsewhere.
-        #
-        # @return [String, nil] the first rekey rule's SQL; nil when the edge declares no rekey
-        def rekey_sql = @rules.rekeys.first&.sql
-
-        # Rewrites one journal entry's state from the held shape into the current one.
+        # Rewrites one journal entry from the held shape into the current one.
         #
-        # The reference semantics for rename, move, convert, drop, and the aggregate-level `was:`.
-        # `compute` is not applied here — its SQL is the only implementation, audited separately.
+        # The reference semantics for derive, rename, move, convert, drop, `was:` and the id a
+        # `rekey_to` takes.
         #
         # @param entry [Ports::Persistence::Entry] the entry as stored, with Symbol
         #   top-level keys and String keys nested in a value-object Hash
         # @return [Ports::Persistence::Entry] a new entry with translated state and the same
-        #   `operation`, `id` and `mirrors`; `entry` itself when it is not a save or has no state
+        #   `operation` and `mirrors`, and the same `id` unless a `rekey_to` gives it a value;
+        #   `entry` itself when it is not a save or has no state
         # @raise [Runtime::WiringError] if a convert value is missing from its `values` table, or a
         #   move/convert would nest under a destination already holding a non-Hash value
         def translate(entry)
@@ -120,8 +111,9 @@ module Hecks
           # Deep, not shallow: a move or convert reaches into a nested
           # value-object hash, and a shallow dup would quietly mutate
           # the caller's copy of the original entry.
+          id = rekeyed_id(entry)
           state = rewrite(deep_dup(entry.state))
-          Entry.new(operation: entry.operation, id: entry.id, state: state, mirrors: entry.mirrors)
+          Entry.new(operation: entry.operation, id: id, state: state, mirrors: entry.mirrors)
         end
 
         # Reports whether a declared retype pairs two type names as the same shape.

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/base_sql.rb

@@ -29,18 +29,6 @@ module Hecks
             )
           SQL
 
-          # The Layer-3 approvals of translation edges.
-          APPROVALS_SQL = <<~SQL.freeze
-            CREATE TABLE IF NOT EXISTS hecks_approvals (
-              domain           text NOT NULL,
-              from_label       text NOT NULL,
-              to_label         text NOT NULL,
-              edge_digest      text NOT NULL,
-              reviewed_ordinal bigint NOT NULL,
-              approved_at      timestamptz NOT NULL DEFAULT now()
-            )
-          SQL
-
           # An owned sequence default, not generated always as identity, which
           # partitioned tables only support from Postgres 17.
           JOURNAL_SQL = <<~SQL.freeze

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/domain_rename.rb

@@ -76,7 +76,7 @@ module Hecks
           end
 
           def rename_rows!
-            %w[hecks_eras hecks_era_texts hecks_approvals].each do |table|
+            %w[hecks_eras hecks_era_texts].each do |table|
               @db.exec_params("UPDATE #{table} SET domain = $1 WHERE domain = $2", [@domain, @formerly_known_as])
             end
             # hecks_attestations is created lazily on first reattest!, so it may not exist.

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/era_store.rb

@@ -6,8 +6,8 @@ module Hecks
   module Adapters
     class PostgresEra
       class Lineage
-        # CRUD over `hecks_eras`/`hecks_era_texts`/`hecks_approvals`: era text
-        # integrity, archiving, Layer-3 approvals, and once-only era naming.
+        # CRUD over `hecks_eras`/`hecks_era_texts`: era text
+        # integrity, archiving, and once-only era naming.
         module EraStore
           # Verifies each held text's digest before returning it; a missing digest is backfilled.
           def eras
@@ -48,26 +48,6 @@ module Hecks
             )
           end
 
-          # Always inserts a new row; `approval_for` picks the latest for a shape pair.
-          def record_approval!(from:, to:, edge_digest:)
-            @db.exec_params(
-              "INSERT INTO hecks_approvals (domain, from_label, to_label, edge_digest, reviewed_ordinal) " \
-              "VALUES ($1, $2, $3, $4, $5)",
-              [@domain, from, to, edge_digest, last_ordinal]
-            )
-          end
-
-          def approval_for(from:, to:)
-            rows = @db.exec_params(
-              "SELECT edge_digest, reviewed_ordinal FROM hecks_approvals " \
-              "WHERE domain = $1 AND from_label = $2 AND to_label = $3 ORDER BY approved_at DESC, reviewed_ordinal DESC LIMIT 1",
-              [@domain, from, to]
-            )
-            return nil if rows.ntuples.zero?
-
-            { edge_digest: rows[0]["edge_digest"], reviewed_ordinal: rows[0]["reviewed_ordinal"].to_i }
-          end
-
           # Sets hash/label only once; nothing ever recomputes a stored name to verify it.
           def mint_name!(ordinal, hash, label)
             @db.exec_params(

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage/provisioning.rb

@@ -118,7 +118,6 @@ module Hecks
             # NULL reads as 1.
             @db.exec("ALTER TABLE hecks_eras ADD COLUMN IF NOT EXISTS canon_form int")
             @db.exec(ERA_TEXTS_SQL)
-            @db.exec(APPROVALS_SQL)
           end
 
           def create_journal!

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage.rb

@@ -28,8 +28,6 @@ module Hecks
         include FieldCache
         include TransformInstaller
 
-        JOURNAL_COLUMNS = "ordinal, era, aggregate, aggregate_id, operation, state, mirrors".freeze
-
         # Longer identifiers are silently truncated by Postgres, so `qualified_name` hashes them.
         POSTGRES_IDENTIFIER_LIMIT = 63
 
@@ -100,7 +98,15 @@ module Hecks
           return full if full.bytesize <= POSTGRES_IDENTIFIER_LIMIT
 
           digest = Digest::SHA256.hexdigest(full)[0, 8]
-          "#{full.byteslice(0, POSTGRES_IDENTIFIER_LIMIT - digest.bytesize - 1)}_#{digest}"
+          "#{whole_characters(full, POSTGRES_IDENTIFIER_LIMIT - digest.bytesize - 1)}_#{digest}"
+        end
+
+        # The longest prefix of `text` made of whole characters that fits in `limit` bytes, so a
+        # multi-byte character is dropped rather than cut in half.
+        def whole_characters(text, limit)
+          bytes = text.byteslice(0, limit)
+          bytes = bytes.byteslice(0, bytes.bytesize - 1) until bytes.valid_encoding?
+          bytes
         end
 
         def quote(name) = PG::Connection.quote_ident(name.to_s)

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage_manager/minter.rb

@@ -2,7 +2,6 @@ require_relative "../../../../../../runtime/registry"
 require_relative "../../storage_shape"
 require_relative "../../translation/audit"
 require_relative "../../translation/scaffold"
-require_relative "../../translation/approval_file"
 require_relative "context"
 require_relative "refusals"
 
@@ -11,7 +10,7 @@ module Hecks
     class PostgresEra
       module LineageManager
         # Names the source era, resolves its one outgoing translation edge, and mints the
-        # next era once approval, coverage and the audited chain all check out.
+        # next era once coverage and the audited chain check out.
         module Minter
           include Refusals
 
@@ -20,8 +19,7 @@ module Hecks
           # @param context [Context] the era check so far; `latest` is the latest held era, named
           #   here if it has no name yet
           # @return [Integer] the ordinal of the era minted
-          # @raise [Runtime::WiringError] if the edge, its approval, its coverage or its audit
-          #   refuses
+          # @raise [Runtime::WiringError] if the edge, its coverage or its audit refuses
           def mint!(context)
             ensure_named!(context.lineage, context.latest)
             context = context.with(latest: context.lineage.eras.last)
@@ -41,29 +39,6 @@ module Hecks
             edges.first
           end
 
-          # Refuses a mint whose edge carries a compute or rekey rule without an approval.
-          #
-          # A compute or rekey's only verification is a human-approved audit sample. Two approvals
-          # satisfy it: one recorded in the journal that matches the edge and the journal's current
-          # tip, or a committed `translations/<edge>.approval` that matches the edge's digest and
-          # records a passed rehearsal on a compatible host release. A committed approval that
-          # applies is written into the journal, so the journal stays the single history.
-          def ensure_compute_rekey_approved!(context, edge)
-            return unless Translation::ApprovalFile.needs_rehearsal?(edge)
-
-            approval = context.lineage.approval_for(from: edge.from, to: edge.to)
-            digest = Translation::Audit.edge_digest(edge)
-            tip = context.lineage.last_ordinal
-            return if approved_at_tip?(approval, digest, tip)
-
-            if Translation::ApprovalFile.applicable(context.directory, edge)
-              context.lineage.record_approval!(from: edge.from, to: edge.to, edge_digest: digest)
-              return
-            end
-
-            refuse_unapproved!(context, edge, approval, tip)
-          end
-
           # Diffs the held era against the current shape and writes the edge file —
           # confident rules inline, ambiguities as parse-refusing `unresolved` lines.
           def scaffold!(_registry, bluebook, lineage, latest, directory)
@@ -104,10 +79,9 @@ module Hecks
             chain
           end
 
-          # The edge leaving the held era, once resolved, approved and found to cover the diff.
+          # The edge leaving the held era, once resolved and found to cover the diff.
           def verified_edge!(context)
             edge = resolve_edge!(context)
-            ensure_compute_rekey_approved!(context, edge)
             check_coverage!(context.registry, context.bluebook, shadow(context.latest[:held_text]), edge)
             edge
           end

data/lib/hecks/ports/persistence/plugins/era/postgres_era/lineage_manager/refusals.rb

@@ -2,8 +2,8 @@ module Hecks
   module Adapters
     class PostgresEra
       module LineageManager
-        # The refusals a mint raises: toward the scaffold when no edge exists, and for a forked,
-        # stale or unapproved edge. Each is built from the era check's `Context`.
+        # The refusals a mint raises: toward the scaffold when no edge exists, and for a forked or
+        # stale edge. Each is built from the era check's `Context`.
         module Refusals
           # Refuses toward the authoring loop, or, under HECKS_SCAFFOLD=1, scaffolds the
           # missing edge first and names the file it wrote.
@@ -37,30 +37,6 @@ module Hecks
                                        "re-run hecks scaffold_translation", minting: false)
           end
 
-          # Whether the journal already holds an approval of this edge at the journal's tip.
-          def approved_at_tip?(approval, digest, tip)
-            approval && approval[:edge_digest] == digest && approval[:reviewed_ordinal] == tip
-          end
-
-          def refuse_unapproved!(context, edge, approval, tip)
-            if approval && approval[:edge_digest] == Translation::Audit.edge_digest(edge)
-              raise era_refusal(context, "the journal advanced past the approved " \
-                                         "review (ordinal #{approval[:reviewed_ordinal]} reviewed, #{tip} now) — the samples a " \
-                                         "human approved no longer cover the data; re-run hecks audit_translation with --approve")
-            end
-
-            mismatch = Translation::ApprovalFile.host_mismatch(context.directory, edge)
-            raise era_refusal(context, unapproved_reason(mismatch))
-          end
-
-          def unapproved_reason(mismatch)
-            return "the committed approval does not apply — #{mismatch}" if mismatch
-
-            "this edge carries a compute or rekey " \
-              "rule, and the audit's human-approved sample is its only verification — run " \
-              "hecks audit_translation with --approve, then boot again"
-          end
-
           # Builds the refusal; a mint's own refusals say "cannot mint era N of X", the
           # edge-resolution ones say "cannot boot X".
           def era_refusal(context, text, minting: true)