hecks 3.14.0 → 5.0.0

data/lib/hecks/hecks/adapters/journal_store/examination.rb

@@ -15,15 +15,14 @@ module Hecks
       module Examination
         # What every fact is until an examination finds otherwise.
         NEUTRAL = {
-          capable: false, held: 0, forks: 0, contested: 0, edges: 0, bound: 0, candidates: 0,
-          audited: false, rehearsal_needed: false, rehearsal_recorded: false,
+          capable: false, held: 0, forks: 0, contested: 0, bound: 0, candidates: 0,
           drifted: false, loadable: false, shape_kept: false
         }.freeze
 
         # Examines the domain a change was asked for.
         #
         # @param held [Hash] the `Era` record: `operation`, `domain`, and whichever of `winners`,
-        #   `era`, `aggregates` and the rehearsal fields the request carried
+        #   `era` and `aggregates` the request carried
         # @return [Hash{Symbol => Hash}] every fact, as `{ value: x }`, and the request's own
         #   `operation`, which the reactions to the examination read
         # @raise [Runtime::NotFound] if the domain cannot be loaded or has no such era
@@ -90,26 +89,6 @@ module Hecks
           { candidates: compaction.candidates.size, bound: compaction.bound.size }
         end
 
-        def examine_approve_translation(held)
-          domain = HeldDomain.open(plain(held[:domain]))
-          return {} unless domain.capable?
-
-          domain.reading do |lineage|
-            eras = domain.held_eras(lineage)
-            finding = eras.empty? ? nil : EdgeAudit.call(domain, lineage, eras)
-            next { capable: true, held: eras.size } unless finding
-
-            { capable: true, held: eras.size, edges: finding.leaving, audited: finding.ok }.merge(rehearsal_facts(finding, held))
-          end
-        end
-
-        def rehearsal_facts(finding, held)
-          {
-            rehearsal_needed:   Translation::ApprovalFile.needs_rehearsal?(finding.edge),
-            rehearsal_recorded: Translation::ApprovalFile.rehearsed?(rehearsal_block(held))
-          }
-        end
-
         # How many eras, before the latest, do not have exactly one edge leading to the next.
         def forks_in(domain, eras)
           eras.each_cons(2).count do |from, to|

data/lib/hecks/hecks/adapters/journal_store/readings.rb

@@ -18,6 +18,8 @@ module Hecks
       # a domain that holds no era answers that it holds none, and only `hold_first` holds one.
       # What a reading refuses is a `Runtime::NotFound`, the refusal a launcher words as an answer.
       module Readings
+        AUDIT_PASSED = "AUDIT PASSED \u2014 review the samples above; intent is yours to approve."
+
         include Scaffolding
         include Attestation
 
@@ -112,17 +114,7 @@ module Hecks
           return "#{held.bluebook.name} stands at era 1 — no edge to audit." unless finding
           raise Runtime::NotFound, "#{finding.report}\nAUDIT REFUSED." unless finding.ok
 
-          [finding.report, audit_verdict(finding.edge, path)].join("\n")
-        end
-
-        def audit_verdict(edge, path)
-          if Translation::ApprovalFile.needs_rehearsal?(edge)
-            "AUDIT PASSED — this edge carries a compute or rekey rule, and the samples above are its ONLY " \
-              "verification. If they show what you intended, rehearse it against a snapshot and run " \
-              "`hecks approve_translation #{path} --confirm` with the rehearsal; the mint refuses until then."
-          else
-            "AUDIT PASSED — review the samples above; intent is yours to approve."
-          end
+          [finding.report, AUDIT_PASSED].join("\n")
         end
       end
     end

data/lib/hecks/hecks/adapters/journal_store.rb

@@ -42,17 +42,6 @@ module Hecks
         end
       end
 
-      # The rehearsal a compute or rekey edge is approved on, as the block the file carries. A
-      # rehearsal that names no host version ran on this one, so it records this release.
-      def rehearsal_block(held)
-        block = { "snapshot" => plain(held[:snapshot]), "host_version" => plain(held[:host_version]),
-                  "result" => plain(held[:rehearsal]), "at" => plain(held[:rehearsed_at]) }.compact
-        return nil if block.empty?
-
-        block["host_version"] ||= Hecks::VERSION
-        block
-      end
-
       # The era as stored, digest unchecked: a text that drifted is what re-attesting is for.
       def raw_era(domain, lineage, ordinal)
         present = lineage.db.exec("SELECT to_regclass('hecks_eras') AS present")[0]["present"]

data/lib/hecks/hecks/adapters/rehearsal/inquiry.rb

@@ -45,7 +45,7 @@ module Hecks
           refusals, after = edge ? @store.audit(@subject, edge) : [[], {}]
           rust = RustAudit.call(@subject, after)
           report = AuditReport.new(minting: minting, edge: edge, states: after, ruby: refusals, rust: rust)
-          answer(edge, report, (refusals + rust.violations).uniq, limits(edge, rust, report))
+          answer(edge, report, (refusals + rust.violations).uniq, limits(rust, report))
         end
 
         private
@@ -82,7 +82,7 @@ module Hecks
         def copy_facts = census.facts.merge(copy_empty: flag(copy_empty?))
 
         def edge_facts(edge)
-          { minting: plain(minting), edge_present: flag(!edge.nil?), edge_approved: flag(approved?(edge)) }
+          { minting: plain(minting), edge_present: flag(!edge.nil?) }
         end
 
         def eras = @eras ||= @store.eras(@subject)
@@ -97,16 +97,9 @@ module Hecks
           before == @subject.label ? "none" : "next"
         end
 
-        def approved?(edge)
-          return false unless edge
-
-          !Translation::ApprovalFile.needs_rehearsal?(edge) ||
-            !Translation::ApprovalFile.applicable(@subject.directory, edge).nil?
-        end
-
-        def limits(edge, rust, report)
+        def limits(rust, report)
           engine = rust.ran ? [] : [ENGINE_LIMIT]
-          engine + report.limits + ALWAYS + @store.limits(edge) + [journal_limit] + attached_limits +
+          engine + report.limits + ALWAYS + [journal_limit] + attached_limits +
             (@subject.held.capable? ? [] : [binding_note])
         end
 

data/lib/hecks/hecks/adapters/rehearsal/memory_store.rb

@@ -65,15 +65,6 @@ module Hecks
           [refusals, after]
         end
 
-        # @param edge [Bluebook::Translation] the edge
-        # @return [Array<Hash>] what memory cannot apply, as report limits
-        def limits(edge)
-          return [] unless edge && Translation::ApprovalFile.needs_rehearsal?(edge)
-
-          [{ what: "the edge's compute and rekey rules",
-             why:  "they are SQL, which only a postgres copy runs; memory leaves those fields as stored" }]
-        end
-
         private
 
         def records(name) = @document.dig("records", name.to_s) || {}

data/lib/hecks/hecks/adapters/rehearsal/postgres_reading.rb

@@ -42,10 +42,6 @@ module Hecks
           end
         end
 
-        # @param _edge [Bluebook::Translation] unused
-        # @return [Array<Hash>] none: a postgres copy runs the compiled rules itself
-        def limits(_edge) = []
-
         private
 
         def schema_candidates(subject)

data/lib/hecks/hecks/codebase.behaviors

@@ -170,6 +170,12 @@ Hecks.behaviors "Codebase" do
     expect refused: "a port is 1 to 65535"
   end
 
+  test "Compose refuses a port that is not one" do
+    tests "Compose", on: "CorpusRun"
+    input port: { value: 70_000 }, run: { value: "compose" }
+    expect refused: "a port is 1 to 65535"
+  end
+
   test "ServeQueryIrMcp refuses a run that is not named" do
     tests "ServeQueryIrMcp", on: "CorpusRun"
     input run: { value: "" }

data/lib/hecks/hecks/codebase.bluebook

@@ -2467,6 +2467,22 @@ Hecks.bluebook "Hecks" do
       emits PresentRequested
     end
 
+    command "Compose" do
+      role "Maintainer"
+      goal "Serve the Composer, a live bluebook editor over one domain directory, on a local port until stopped"
+
+      attribute :port,    Port, optional: true
+      attribute :domains, PathList, optional: true
+      attribute :run,     RunKey
+
+      sets :port
+      sets :domains
+      sets :run
+      sets :operation, to: "compose"
+
+      emits ComposeRequested
+    end
+
     # What the tree reported about itself, held against every request: nothing here runs
     # outside a hecks checkout (hecks.gemspec beside lib/).
     command "Accept" do
@@ -2571,6 +2587,11 @@ Hecks.bluebook "Hecks" do
     trigger CorpusRun::SourceTree::Examine, with: { run: :run }
   end
 
+  policy "ExamineWhenComposeRequested" do
+    on      "CorpusRun.ComposeRequested"
+    trigger CorpusRun::SourceTree::Examine, with: { run: :run }
+  end
+
   policy "AcceptCorpusWhenExamined" do
     on      "CorpusRun.CorpusExamined"
     trigger CorpusRun::Accept, with: { checkout: :checkout }

data/lib/hecks/hecks/composer.behaviors

@@ -0,0 +1,68 @@
+Hecks.behaviors "Composer" do
+  vision "A draft is opened, revised, judged by its check and talked about with an agent, one recorded step at a time."
+
+  loads "hecks.bluebook", "custodian.bluebook", "tooling.bluebook", "rehearsal.bluebook", "codebase.bluebook", "context_map.hecksagon", "hecks.hecksagon", "environments/memory.world"
+
+  test "Begin opens a chapter for editing" do
+    tests "Begin", on: "Draft"
+    input slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    expect status:"drafting"
+  end
+
+  test "Revise replaces the text of a draft" do
+    tests "Revise", on: "Draft"
+    setup  "Composer::Draft.Begin", slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    input  slug: { value: "account" }, text: { value: "Hecks.bluebook \"Account\" do\nend" }
+    expect emits: ["DraftRevised"]
+  end
+
+  test "Accept records a draft that passed its check" do
+    tests "Accept", on: "Draft"
+    setup  "Composer::Draft.Begin", slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    input  slug: { value: "account" }, note: { value: "ok" }
+    expect status:"valid"
+  end
+
+  test "Reject records a draft that failed its check" do
+    tests "Reject", on: "Draft"
+    setup  "Composer::Draft.Begin", slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    input  slug: { value: "account" }, note: { value: "line 3: expected one of: attribute, command" }
+    expect status:"invalid"
+  end
+
+  test "Revise returns a valid draft to drafting" do
+    tests "Revise", on: "Draft"
+    setup  "Composer::Draft.Begin", slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    setup  "Composer::Draft.Accept", slug: { value: "account" }, note: { value: "ok" }
+    input  slug: { value: "account" }, text: { value: "Hecks.bluebook \"Account\" do\nend" }
+    expect status:"drafting"
+  end
+
+  test "Ask puts a request to the conversation" do
+    tests "Ask", on: "Draft"
+    setup  "Composer::Draft.Begin", slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    input  slug: { value: "account" }, sequence: { value: 1 }, said: { value: "add a Refund command" }
+    expect emits: ["TurnAsked"]
+  end
+
+  test "Ask refuses a turn that says nothing" do
+    tests "Ask", on: "Draft"
+    setup  "Composer::Draft.Begin", slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    input  slug: { value: "account" }, sequence: { value: 1 }, said: { value: "" }
+    expect refused: "says something"
+  end
+
+  test "Answer records the agent's reply after a request" do
+    tests "Answer", on: "Draft"
+    setup  "Composer::Draft.Begin", slug: { value: "account" }, chapter_name: { value: "Account" }, text: { value: "" }
+    setup  "Composer::Draft.Ask", slug: { value: "account" }, sequence: { value: 1 }, said: { value: "add a Refund command" }
+    input  slug: { value: "account" }, sequence: { value: 2 }, said: { value: "Added Refund." }, text: { value: "Hecks.bluebook \"Account\" do\nend" }
+    expect emits: ["TurnAnswered"]
+  end
+
+  test "Accept refuses a draft that was never begun" do
+    tests "Accept", on: "Draft"
+    input slug: { value: "nothing" }, note: { value: "ok" }
+    expect refused: "no Draft with"
+  end
+end

data/lib/hecks/hecks/context_map.hecksagon

@@ -8,6 +8,6 @@ end
 
 # The attached chapters (hecks.hecksagon `attaches`): each is a bounded context whose store comes
 # from hecks.world's `default_adapter`, so the memory overlay swaps them with the Hecks chapter.
-%w[Bluebook Hecksagon World Adapter Port Translation Expression Tenancy Deploy Site Tickets QualityControl].each do |chapter|
+%w[Bluebook Hecksagon World Adapter Port Translation Expression Tenancy Deploy Site Tickets Composer QualityControl].each do |chapter|
   Hecks.hecksagon(chapter) { attaches "Governance" }
 end

data/lib/hecks/hecks/custodian.behaviors

@@ -105,12 +105,6 @@ Hecks.behaviors "Custodian" do
     expect refused: "an era is counted from one"
   end
 
-  test "ApproveTranslation refuses a rehearsal that neither passed nor failed" do
-    tests "ApproveTranslation", on: "Era"
-    input domain: { value: "examples/pizzas" }, run: { value: "approve" }, confirm: { value: true }, rehearsal: { value: "maybe" }
-    expect refused: "must match"
-  end
-
   test "CompactHeki keeps a domain that is not there as a refused change" do
     tests "CompactHeki", on: "Era"
     input domain: { value: "/tmp/hecks-behaviors-absent/heki-domain" }, run: { value: "compact" }, confirm: { value: true }

data/lib/hecks/hecks/custodian.bluebook

@@ -524,20 +524,12 @@ policy "RecordTheEra" do
     attribute :era,                 Ordinal,       optional: true
     attribute :aggregates,          AggregateList, optional: true
     attribute :confirm,             Switch,        optional: true
-    attribute :snapshot,            Snapshot,      optional: true
-    attribute :host_version,        HostVersion,   optional: true
-    attribute :rehearsal,           Verdict,       optional: true
-    attribute :rehearsed_at,        Moment,        optional: true
     attribute :capable,             Switch,        optional: true
     attribute :held,                Count,         optional: true
     attribute :forks,               Count,         optional: true
     attribute :contested,           Count,         optional: true
-    attribute :edges,               Count,         optional: true
     attribute :bound,               Count,         optional: true
     attribute :candidates,          Count,         optional: true
-    attribute :audited,             Switch,        optional: true
-    attribute :rehearsal_needed,    Switch,        optional: true
-    attribute :rehearsal_recorded,  Switch,        optional: true
     attribute :drifted,             Switch,        optional: true
     attribute :loadable,            Switch,        optional: true
     attribute :shape_kept,          Switch,        optional: true
@@ -558,7 +550,7 @@ policy "RecordTheEra" do
 
     value_object "OperationName" do
       attribute :value, String,
-                pattern: '^(hold_first|merge_tail|reattest|backfill_projections|compact|compact_heki|approve_translation)$'
+                pattern: '^(hold_first|merge_tail|reattest|backfill_projections|compact|compact_heki)$'
     end
 
     # `id:old,id:new`: which world's record wins for each id both worlds touched since the cut.
@@ -585,24 +577,6 @@ policy "RecordTheEra" do
       attribute :value, Integer
     end
 
-    # The rehearsal a compute or rekey edge is approved on: the snapshot it ran against, the host
-    # that ran it, whether it passed, and when.
-    value_object "Snapshot" do
-      attribute :value, String, matches: :not_empty
-    end
-
-    value_object "HostVersion" do
-      attribute :value, String, matches: :present
-    end
-
-    value_object "Verdict" do
-      attribute :value, String, pattern: '^(pass|fail)$'
-    end
-
-    value_object "Moment" do
-      attribute :value, String, pattern: '^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[^ \t\n\r]+$'
-    end
-
     value_object "Report" do
       attribute :value, String
     end
@@ -730,34 +704,6 @@ policy "RecordTheEra" do
       emits HekiCompactionRequested
     end
 
-    # Writes `translations/<edge>.approval` beside the edge, for the host to apply at its next
-    # boot. An edge with a compute or rekey rule also needs the rehearsal a person ran by hand.
-    command "ApproveTranslation" do
-      role "Operator"
-      goal "Approve the edge that leads a domain's latest era to its current shape, in a committed file"
-
-      attribute :domain,       DomainPath
-      attribute :run,          RunKey
-      attribute :confirm,      Switch,      optional: true
-      attribute :snapshot,     Snapshot,    optional: true
-      attribute :host_version, HostVersion, optional: true
-      attribute :rehearsal,    Verdict,     optional: true
-      attribute :rehearsed_at, Moment,      optional: true
-
-      given("the approval is confirmed") { confirm.value == true }
-
-      sets :domain
-      sets :run
-      sets :confirm
-      sets :snapshot
-      sets :host_version
-      sets :rehearsal
-      sets :rehearsed_at
-      sets :operation, to: "approve_translation"
-
-      emits ApprovalRequested
-    end
-
     # The facts the journal store reported, held against the change that was asked for.
     command "Permit" do
       role "System"
@@ -768,12 +714,8 @@ policy "RecordTheEra" do
       attribute :held,               Count
       attribute :forks,              Count
       attribute :contested,          Count
-      attribute :edges,              Count
       attribute :bound,              Count
       attribute :candidates,         Count
-      attribute :audited,            Switch
-      attribute :rehearsal_needed,   Switch
-      attribute :rehearsal_recorded, Switch
       attribute :drifted,            Switch
       attribute :loadable,           Switch
       attribute :shape_kept,         Switch
@@ -795,13 +737,6 @@ policy "RecordTheEra" do
       given("no projection reads the journal that would be emptied") do
         (operation.value != "compact" && operation.value != "compact_heki") || bound.value == 0
       end
-      given("exactly one edge leaves the latest era") do
-        operation.value != "approve_translation" || edges.value == 1
-      end
-      given("the audit passed") { operation.value != "approve_translation" || audited.value }
-      given("a rehearsal that passed is recorded for an edge with a compute or rekey rule") do
-        operation.value != "approve_translation" || !rehearsal_needed.value || rehearsal_recorded.value
-      end
       given("the held text no longer matches its digest: there is nothing to re-attest") do
         operation.value != "reattest" || drifted.value
       end
@@ -816,12 +751,8 @@ policy "RecordTheEra" do
       sets :held
       sets :forks
       sets :contested
-      sets :edges
       sets :bound
       sets :candidates
-      sets :audited
-      sets :rehearsal_needed
-      sets :rehearsal_recorded
       sets :drifted
       sets :loadable
       sets :shape_kept
@@ -930,17 +861,11 @@ policy "RecordTheEra" do
     trigger Era::JournalStore::Examine, with: { run: :run }
   end
 
-  policy "ExamineWhenApprovalRequested" do
-    on      "Era.ApprovalRequested"
-    trigger Era::JournalStore::Examine, with: { run: :run }
-  end
-
   policy "PermitWhenExamined" do
     on      "Era.EraExamined"
     trigger Era::Permit, with: {
-      capable: :capable, held: :held, forks: :forks, contested: :contested, edges: :edges,
-      bound: :bound, candidates: :candidates, audited: :audited,
-      rehearsal_needed: :rehearsal_needed, rehearsal_recorded: :rehearsal_recorded,
+      capable: :capable, held: :held, forks: :forks, contested: :contested,
+      bound: :bound, candidates: :candidates,
       drifted: :drifted, loadable: :loadable, shape_kept: :shape_kept
     }
   end
@@ -956,8 +881,6 @@ policy "RecordTheEra" do
         (operation.value == "merge_tail" && (held.value <= 1 || forks.value != 0 || contested.value != 0)) ||
         ((operation.value == "compact" || operation.value == "compact_heki") &&
           (candidates.value <= 0 || bound.value != 0)) ||
-        (operation.value == "approve_translation" &&
-          (edges.value != 1 || !audited.value || (rehearsal_needed.value && !rehearsal_recorded.value))) ||
         (operation.value == "reattest" && (!drifted.value || !loadable.value || !shape_kept.value))
     end
     trigger Era::Abandon, with: { refusal: "the journal's facts do not admit this change" }

data/lib/hecks/hecks/hecks.hecksagon

@@ -2,8 +2,8 @@ Hecks.hecksagon "Hecks" do
   attaches "Governance"
 
   # The chapters the gem carries: the language declared in itself (Paging comes with Bluebook),
-  # Expression, Tenancy, Deploy, Site, Tickets and QualityControl (the last three bring their own ports).
-  %w[Bluebook Hecksagon World Adapter Port Translation Expression Tenancy Deploy Site Tickets QualityControl]
+  # Expression, Tenancy, Deploy, Site, Tickets, Composer and QualityControl (the last three bring their own ports).
+  %w[Bluebook Hecksagon World Adapter Port Translation Expression Tenancy Deploy Site Tickets Composer QualityControl]
     .each { |chapter| attaches chapter }
   # Persistence is not bound here: hecks.world's `default_adapter` binds every aggregate, so
   # environments/memory.world can swap the whole domain without a double bind.

data/lib/hecks/hecks/hecks.world

@@ -61,7 +61,7 @@ Hecks.world "Hecks" do
                                       CodemodRun TestSuiteRun CorpusRun PublishingRun PromotionRun Release
                                       SyntaxBootCache],
                        newcomer: %w[launch.init launch.interview operation.open_console],
-                       chapters: %w[Deploy Governance Tenancy Site Tickets QualityControl],
+                       chapters: %w[Deploy Governance Tenancy Site Tickets Composer QualityControl],
                        maintainer_chapters: %w[Bluebook Hecksagon World Adapter Port Translation Expression],
                        memory_commands: %w[console init interview],
                        legacy: %w[run docs narrate ir stores model_check smoke_test

data/lib/hecks/hecks/rehearsal.bluebook

@@ -35,7 +35,6 @@ Hecks.bluebook "Hecks" do
     attribute :after,          ShapeLabel,  optional: true
     attribute :minting,        Minting,     optional: true
     attribute :edge_present,   Switch,      optional: true
-    attribute :edge_approved,  Switch,      optional: true
     attribute :refused_rows,   list_of(RefusedRow), optional: true
     attribute :refusal_total,  Count,       optional: true
     attribute :audited,        Switch,      optional: true
@@ -279,15 +278,14 @@ Hecks.bluebook "Hecks" do
       emits RehearsalBooted
     end
 
-    # The mint's own three layers and its edge, approval and coverage rules, run over the copy.
+    # The mint's own three layers and its edge and coverage rules, run over the copy.
     command "Audit" do
       role "System"
-      goal "Record whether an edge leads to the shape and is approved, and every row the mint's audit would refuse"
+      goal "Record whether an edge leads to the shape, and every row the mint's audit would refuse"
 
       reference_to RehearsalRun
       attribute :minting,       Minting
       attribute :edge_present,  Switch
-      attribute :edge_approved, Switch
       attribute :refused_rows,  list_of(RefusedRow), optional: true
       attribute :refusal_total, Count
       attribute :audited,       Switch
@@ -302,7 +300,6 @@ Hecks.bluebook "Hecks" do
 
       sets :minting
       sets :edge_present
-      sets :edge_approved
       sets :refused_rows
       sets :refusal_total
       sets :audited
@@ -326,7 +323,6 @@ Hecks.bluebook "Hecks" do
       attribute :verdict,       Verdict
       attribute :refusal_total, Count
       attribute :edge_present,  Switch
-      attribute :edge_approved, Switch
 
       given("a rehearsal that finds a refused row would not mint") { refusal_total.value == 0 }
       given("a rehearsal judged to mint names that verdict") { verdict.value == "would_mint" }
@@ -439,7 +435,7 @@ Hecks.bluebook "Hecks" do
 
   policy "RecordAuditWhenStoreExamined" do
     on      "RehearsalRun.StoreExamined"
-    trigger RehearsalRun::Audit, with: { minting: :minting, edge_present: :edge_present, edge_approved: :edge_approved,
+    trigger RehearsalRun::Audit, with: { minting: :minting, edge_present: :edge_present,
                                           refused_rows: :refused_rows, refusal_total: :refusal_total,
                                           audited: :audited, rows_examined: :rows_examined,
                                           rust_rows_examined: :rust_rows_examined,
@@ -451,11 +447,10 @@ Hecks.bluebook "Hecks" do
   policy "JudgeWhenNothingWouldStopTheMint" do
     on      "RehearsalRun.RehearsalAudited"
     where do
-      (minting.value != "next" || edge_present.value) && refusal_total.value == 0 &&
-        (minting.value != "next" || edge_approved.value)
+      (minting.value != "next" || edge_present.value) && refusal_total.value == 0
     end
     trigger RehearsalRun::Judge, with: { verdict: "would_mint", refusal_total: :refusal_total,
-                                          edge_present: :edge_present, edge_approved: :edge_approved }
+                                          edge_present: :edge_present }
   end
 
   policy "WithholdWhenNoEdgeLeadsOn" do
@@ -468,10 +463,9 @@ Hecks.bluebook "Hecks" do
   policy "WithholdWhenTheMintWouldRefuse" do
     on      "RehearsalRun.RehearsalAudited"
     where do
-      (minting.value != "next" || edge_present.value) &&
-        (refusal_total.value > 0 || (minting.value == "next" && !edge_approved.value))
+      (minting.value != "next" || edge_present.value) && refusal_total.value > 0
     end
     trigger RehearsalRun::Withhold, with: { verdict: "would_refuse",
-                                             refusal: "the mint would refuse: see the refused rows and the edge's approval" }
+                                             refusal: "the mint would refuse: see the refused rows" }
   end
 end

data/lib/hecks/kernel_capabilities/templates.rb

@@ -30,13 +30,13 @@ module Hecks
             /// variant names — `hecks measure_kernel_coverage`'s own existence
             /// check reads this, so the file-name spelling here is the ONE
             /// place that ever needs to change if a name is renamed.
-            pub fn module_name(&self) -> &'static str {
+            pub const fn module_name(&self) -> &'static str {
                 match self {
         %<arms>s
                 }
             }
 
-            pub const ALL: &'static [%<enum_name>s] = &[%<all>s];
+            pub const ALL: &'static [Self] = &[%<all>s];
         }
       RUST
 
@@ -78,8 +78,8 @@ module Hecks
                      directory: shapes ? "attribute_shapes" : "expression_operators",
                      mods: names.map { |name| "pub mod #{name};" }.join("\n"),
                      variants: names.map { |name| "    #{pascal(name)}," }.join("\n"),
-                     arms: names.map { |name| "            #{enum_name}::#{pascal(name)} => #{name.to_s.inspect}," }.join("\n"),
-                     all: names.map { |name| "#{enum_name}::#{pascal(name)}" }.join(", "))
+                     arms: names.map { |name| "            Self::#{pascal(name)} => #{name.to_s.inspect}," }.join("\n"),
+                     all: names.map { |name| "Self::#{pascal(name)}" }.join(", "))
       end
 
       # @param name [String, Symbol] a snake_case capability name

data/lib/hecks/kernel_capabilities.rb

@@ -42,7 +42,7 @@ module Hecks
         File.join(kernel, "attribute_shapes/mod.rs")     => shapes_module,
         File.join(kernel, "expression_operators/mod.rs") => operators_module
       }
-      ProjectionFiles::Result.new(content, [])
+      ProjectionFiles::Result.new(RustFormat.files(content), [])
     end
 
     # Writes the capability modules.

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

@@ -846,7 +846,6 @@ Hecks.bluebook "Bluebook" do
       member script: "backfill_era_projections", section: "Custodian", aggregate: "Era", verb: "backfill_projections"
       member script: "scaffold_translation", section: "Custodian", aggregate: "Era", verb: "scaffold_translation"
       member script: "translation_audit", section: "Custodian", aggregate: "Era", verb: "audit_translation"
-      member script: "translation_audit", section: "Custodian", aggregate: "Era", verb: "approve_translation"
       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"
@@ -954,8 +953,8 @@ Hecks.bluebook "Bluebook" do
     # hand-typed copies.
     value_object "RustReservedWord" do
       attribute :word, String,
-                one_of: ["as", "break", "const", "continue", "crate", "dyn", "else", "enum", "extern", "false",
-                         "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub",
+                one_of: ["as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum",
+                         "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move", "mut", "pub",
                          "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "type",
                          "unsafe", "use", "where", "while", "abstract", "become", "box", "do", "final", "macro",
                          "override", "priv", "typeof", "unsized", "virtual", "yield", "try"]