samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -2,7 +2,6 @@
 
 require "fileutils"
 require_relative "file_digest"
-require_relative "bundle_hook"
 require_relative "manifest"
 require_relative "provenance"
 require_relative "../version"
@@ -13,22 +12,25 @@ module Samagotchi
 
     # The install of a bundle's parts that live in its own dir
     # (<bundles>/<name>/, Provenance#bundle_dir) rather than in the
-    # memories dir: hooks/*.rb, guardrails/*.yml, the plugin file and
-    # scripts/*. Each replaces what an earlier version installed. Installer
+    # memories dir: guardrails/*.yml, the plugin file and scripts/*. Each
+    # replaces what an earlier version installed. An older chi's record
+    # with class-file hooks has them removed (#retire_hooks): chi no longer
+    # loads them, and the Installer refuses a source that has any. Installer
     # runs it after the memories; it adds to the installer's results and
     # warnings, and #run returns what the record (Provenance#write) keeps.
     # A dev install (+dev+, `chi bundle install --dev`) links each file to
     # the source instead of copying it, and warns of no checksum mismatch.
     # An edited file it replaces or removes is copied to the trash first,
-    # under its subfolder (Trash#copy_edit); a link never is.
+    # under its subfolder (Trash#copy_edits); a link never is.
     class AssetInstaller
       # What was installed: the paths Provenance#write records (each
       # empty / nil on a dry run).
-      #   hooks       every hook basename the bundle ships
-      #   hook_files, guardrail_files, script_files
-      #               basename => installed path
+      #   guardrail_files, script_files  basename => installed path
       #   plugin_file the installed plugin file, nil without one
-      Installed = Data.define(:hooks, :hook_files, :guardrail_files, :plugin_file, :script_files)
+      Installed = Data.define(:guardrail_files, :plugin_file, :script_files)
+
+      # The retire's summary words (Installer#summary): why the hooks went.
+      RETIRED = "chi no longer loads class-file bundle hooks"
 
       # @param source_dir [String] the normalized bundle source
       # @param manifest [Manifest, nil] nil for a non-strict install without one
@@ -61,145 +63,69 @@ module Samagotchi
       # @raise [Installer::InstallError] the manifest names a plugin or
       #   script the bundle doesn't have
       def run
-        install_hooks
-        prune_dropped_hooks if (@upgrade || (@dev && @existing&.dev)) && @existing && !@dry_run
-        verify_hook_checksums if @manifest && @strict && !@dev
         incoming_rules = Dir.glob(File.join(@bundle_dir, "guardrails", "*.yml")).sort
                             .reject { |src| linked_out?(src, "guardrails/#{File.basename(src)}") }
         guardrail_files = install_guardrails(incoming_rules)
         plugin_file = install_plugin
         script_files = install_scripts
-        warn_hooks_requires_chi
+        # After the plugin and scripts, which raise for a file the manifest
+        # names and the bundle lacks: a refused install leaves hooks/ as it was.
+        retire_hooks
         warn_rules_requires_chi(incoming_rules)
-        Installed.new(hooks: @bundle_hooks, hook_files: @hook_files, guardrail_files: guardrail_files,
-                      plugin_file: plugin_file, script_files: script_files)
+        Installed.new(guardrail_files: guardrail_files, plugin_file: plugin_file, script_files: script_files)
       end
 
-      private
-
-      # Copies the bundle's hooks/*.rb into <bundle_dir>/hooks/: the ones
-      # its manifest lists, else (no hooks: in it) every hooks/*.rb, which is
-      # then added to manifest.hooks with no event (the loader skips it, the
-      # record keeps it). Without a manifest every hooks/*.rb is copied.
-      # Sets @bundle_hooks (every hook the bundle ships) and @hook_files
-      # (basename => installed path, for the record).
-      def install_hooks
-        @bundle_hooks = []
-        @hook_files = {}
-        return install_unlisted_hooks unless @manifest
-
-        hook_entries = @manifest.hooks
-        if hook_entries.empty?
-          Dir.glob(File.join(@bundle_dir, "hooks", "*.rb")).each { |p| hook_entries[File.basename(p)] = BundleHook.new }
-        end
-        hook_entries.keys.each do |basename|
-          next unless basename.is_a?(String) && !basename.empty?
-
-          src = File.join(@bundle_dir, "hooks", basename)
-          # A linked hook isn't the bundle's: not installed, counted or recorded.
-          next hook_entries.delete(basename) if (File.symlink?(src) || File.exist?(src)) && linked_out?(src, "hooks/#{basename}")
+      # Whether the bundle file +src+ reads through a symlink: it is one, or
+      # it (or its dir, hooks/ say) resolves outside +bundle_dir+. A tar,
+      # zip or git repo keeps links; copying through one would install any
+      # file the user can read. MemoryFiles skips linked memories the same
+      # way. ShippedUpdate's plan reads it too.
+      def self.linked?(src, bundle_dir)
+        return true if File.symlink?(src)
 
-          @bundle_hooks << basename
-          install_hook(basename, src) if File.exist?(src)
-        end
+        root = File.realpath(bundle_dir)
+        !File.realpath(src).start_with?("#{root}/")
+      rescue SystemCallError
+        true
       end
 
-      # One listed hook; an upgrade overwrites a local edit with a warning.
-      def install_hook(basename, src)
-        dest = File.join(@provenance.hooks_dir, basename)
-        if @dry_run
-          @results[basename] = { status: File.exist?(dest) && !@force ? "would_skip" : "would_install" }
-          return
-        end
-
-        prev_sha = @existing&.hooks&.dig(basename)&.sha256
-        if @upgrade && File.exist?(dest) && !@force && !Provenance.recorded_sha(prev_sha).empty? && !Provenance.sha_matches?(dest, prev_sha)
-          @warnings << "Hook #{basename} was locally modified; overwriting"
-        end
-
-        FileUtils.mkdir_p(@provenance.hooks_dir)
-        unchanged = File.exist?(dest) && FileUtils.identical?(src, dest)
-        @trash.copy_edit(dest, as: "hooks/#{basename}", recorded: prev_sha, incoming: src)
-        place(src, dest)
-        @results[basename] = if unchanged
-                               { status: "skipped", reason: "already up to date" }
-                             elsif @upgrade && @existing
-                               { status: "updated" }
-                             else
-                               { status: "installed" }
-                             end
-        @hook_files[basename] = dest
-      end
+      private
 
-      # No manifest (a non-strict install): every hooks/*.rb is copied.
-      def install_unlisted_hooks
-        Dir.glob(File.join(@bundle_dir, "hooks", "*.rb")).each do |src|
-          basename = File.basename(src)
-          next if linked_out?(src, "hooks/#{basename}")
-
-          @bundle_hooks << basename
-          if @dry_run
-            @results[basename] = { status: "would_install" }
-          else
-            FileUtils.mkdir_p(@provenance.hooks_dir)
-            dest = File.join(@provenance.hooks_dir, basename)
-            @trash.copy_edit(dest, as: "hooks/#{basename}", recorded: @existing&.hooks&.dig(basename)&.sha256, incoming: src)
-            place(src, dest)
-            @results[basename] = { status: "installed" }
-            @hook_files[basename] = dest
-          end
+      # The hooks/ an older chi installed (class-file hooks, which no longer
+      # load): every file in it goes, an edited one (or one the record
+      # doesn't know) copied to the trash first, a dev link never (it points
+      # at the source, which stays). Each is a :removed result (a dry run's
+      # :would_remove, through #planned) with the RETIRED note; an empty
+      # hooks/ dir goes without a word. The record keeps no hooks
+      # (Provenance#write).
+      def retire_hooks
+        dir = @provenance.hooks_dir
+        return unless File.directory?(dir) || File.symlink?(dir)
+
+        files = File.symlink?(dir) ? [] : Dir.glob("**/*", File::FNM_DOTMATCH, base: dir).sort.reject { |f| File.directory?(File.join(dir, f)) }
+        files.each do |file|
+          @results["hooks/#{file}"] = @dry_run ? planned(retired) : retired
         end
-      end
+        return if @dry_run
 
-      # An upgrade removes the hooks the previous version shipped and this
-      # one doesn't (a local file too, with a warning; a dev link silently).
-      def prune_dropped_hooks
-        @existing.hooks.each_key do |old_key_str|
-          next if @bundle_hooks.include?(old_key_str)
-
-          old_dest = File.join(@provenance.hooks_dir, old_key_str)
-          if File.exist?(old_dest) && !@force && !File.symlink?(old_dest)
-            @warnings << "Bundle no longer includes hook #{old_key_str} but local file exists — removing"
-          end
-          @trash.copy_edit(old_dest, as: "hooks/#{old_key_str}", recorded: @existing.hooks[old_key_str]&.sha256)
-          FileUtils.rm_f(old_dest)
-        end
+        @trash.copy_edits(dir, "hooks", @existing&.hooks&.transform_values(&:sha256))
+        FileUtils.rm_rf(dir)
       end
 
-      # Strict mode: an installed hook whose sha256 differs from the one its
-      # manifest declares warns (as verify_memory_checksums does).
-      def verify_hook_checksums
-        @bundle_hooks.each do |basename|
-          next if @conflicts.key?(basename)
-
-          expected = @manifest.checksum_for_hook(basename)
-          next unless expected
-
-          dest = File.join(@provenance.hooks_dir, basename)
-          next unless File.exist?(dest)
-
-          actual = FileDigest.hex(dest)
-          if actual != expected
-            @warnings << "Checksum mismatch for hook #{basename}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
-          end
-        end
-      end
+      def retired = Installer::FileResult.new(word: :removed, note: RETIRED)
 
       # The bundle's guardrails/*.yml into <bundle_dir>/guardrails/: the
       # set replaces what an earlier version installed. Same bytes as
       # installed are reported up to date, not "Installed".
       # @return [Hash{String => String}] basename => installed path ({} on a dry run)
       def install_guardrails(incoming_rules)
+        target = @provenance.guardrails_dir
+        results = incoming_rules.to_h { |src| [src, result_for(src, File.join(target, File.basename(src)), updated: false)] }
         if @dry_run
-          incoming_rules.each { |src| @results["guardrails/#{File.basename(src)}"] = { status: "would_install" } }
+          results.each { |src, result| @results["guardrails/#{File.basename(src)}"] = planned(result) }
           return {}
         end
 
-        target = @provenance.guardrails_dir
-        unchanged = incoming_rules.select do |src|
-          dest = File.join(target, File.basename(src))
-          File.file?(dest) && FileUtils.identical?(src, dest)
-        end
         @trash.copy_edits(target, "guardrails", @existing&.guardrails, incoming_rules.to_h { |src| [File.basename(src), src] })
         FileUtils.rm_rf(target)
         return {} if incoming_rules.empty?
@@ -208,8 +134,7 @@ module Samagotchi
         incoming_rules.to_h do |src|
           dest = File.join(target, File.basename(src))
           place(src, dest)
-          @results["guardrails/#{File.basename(src)}"] =
-            unchanged.include?(src) ? { status: "skipped", reason: "already up to date" } : { status: "installed" }
+          @results["guardrails/#{File.basename(src)}"] = results[src]
           [File.basename(src), dest]
         end
       end
@@ -235,29 +160,20 @@ module Samagotchi
         if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, @chi_version))
           @warnings << "Plugin #{plugin[:file]} won't load: #{failure}"
         end
+        dest = File.join(@provenance.plugin_dir, plugin[:file])
+        result = result_for(src, dest, updated: @upgrade && @provenance.installed?)
         if @dry_run
-          @results[plugin[:file]] = { status: "would_install" }
+          @results[plugin[:file]] = planned(result)
           return nil
         end
 
-        dest = File.join(@provenance.plugin_dir, plugin[:file])
-        unchanged = File.file?(dest) && FileUtils.identical?(src, dest)
         @trash.copy_edits(@provenance.plugin_dir, "plugin", @existing&.plugin_shas, { plugin[:file] => src })
         FileUtils.rm_rf(@provenance.plugin_dir)
         FileUtils.mkdir_p(@provenance.plugin_dir)
         place(src, dest)
-        @results[plugin[:file]] = if unchanged
-                                    { status: "skipped", reason: "already up to date" }
-                                  elsif @upgrade && @provenance.installed?
-                                    { status: "updated" }
-                                  else
-                                    { status: "installed" }
-                                  end
-        expected = @manifest.checksum_for_plugin
-        actual = FileDigest.hex(dest)
-        if @strict && !@dev && expected && actual != expected
-          @warnings << "Checksum mismatch for plugin #{plugin[:file]}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
-        end
+        @results[plugin[:file]] = result
+        warning = FileDigest.mismatch("plugin #{plugin[:file]}", dest, @manifest.checksum_for_plugin) if @strict && !@dev
+        @warnings << warning if warning
         dest
       end
 
@@ -274,12 +190,15 @@ module Samagotchi
 
           @warnings << "scripts/#{file} is not executable; chmod +x #{src}" if @dev && !File.executable?(src) && !page_only?(file)
         end
-        return {} if @dry_run
-
-        unchanged = scripts.keys.select do |file|
-          dest = File.join(@provenance.scripts_dir, file)
-          File.file?(dest) && FileUtils.identical?(File.join(@bundle_dir, "scripts", file), dest)
+        results = scripts.keys.to_h do |file|
+          [file, result_for(File.join(@bundle_dir, "scripts", file), File.join(@provenance.scripts_dir, file),
+                            updated: @upgrade && @provenance.installed?)]
         end
+        if @dry_run
+          results.each { |file, result| @results["scripts/#{file}"] = planned(result) }
+          return {}
+        end
+
         @trash.copy_edits(@provenance.scripts_dir, "scripts", @existing&.scripts,
                           scripts.keys.to_h { |file| [file, File.join(@bundle_dir, "scripts", file)] })
         FileUtils.rm_rf(@provenance.scripts_dir)
@@ -289,20 +208,38 @@ module Samagotchi
         scripts.to_h do |file, declared|
           dest = File.join(@provenance.scripts_dir, file)
           place(File.join(@bundle_dir, "scripts", file), dest)
-          @results["scripts/#{file}"] = if unchanged.include?(file) then { status: "skipped", reason: "already up to date" }
-                                        elsif @upgrade && @provenance.installed? then { status: "updated" }
-                                        else { status: "installed" }
-                                        end
+          @results["scripts/#{file}"] = results[file]
           FileUtils.chmod(0o755, dest) unless @dev
-          actual = FileDigest.hex(dest)
-          expected = declared.to_s.delete_prefix("sha256:")
-          if @strict && !@dev && !expected.empty? && actual != expected
-            @warnings << "Checksum mismatch for script #{file}: expected #{expected[0..7]}..., got #{actual[0..7]}..."
-          end
+          warning = FileDigest.mismatch("script #{file}", dest, declared.to_s.delete_prefix("sha256:")) if @strict && !@dev
+          @warnings << warning if warning
           [file, dest]
         end
       end
 
+      # What the real run reports for +src+ over +dest+: up to date when the
+      # bytes are the same, else updated (+updated+: an upgrade over an
+      # install, of a file that is there) or installed. A dry run records #planned of it, so the two
+      # can't drift.
+      def result_for(src, dest, updated:)
+        word = if File.file?(dest) && FileUtils.identical?(src, dest) then :up_to_date
+               elsif updated && File.exist?(dest) then :updated
+               else :installed
+               end
+        Installer::FileResult.new(word: word)
+      end
+
+      # A dry run's word for a result: would_install, would_update,
+      # would_remove, or the up to date result as it is (nothing would be
+      # written).
+      def planned(result)
+        case result.word
+        when :installed then result.with(word: :would_install)
+        when :updated then result.with(word: :would_update)
+        when :removed then result.with(word: :would_remove)
+        else result
+        end
+      end
+
       # A file only a block renderer's load names: the page loads it, nothing runs it.
       def page_only?(file)
         @manifest.block_renderers.any? { |renderer| renderer.load.include?(file) } &&
@@ -316,19 +253,8 @@ module Samagotchi
         @dev ? File.symlink(File.realpath(src), dest) : FileUtils.cp(src, dest)
       end
 
-      # Whether the bundle file +src+ reads through a symlink: it is one, or
-      # it (or its dir, hooks/ say) resolves outside the bundle dir. A tar,
-      # zip or git repo keeps links; copying through one would install any
-      # file the user can read. MemoryFiles skips linked memories the same
-      # way.
-      def linked?(src)
-        return true if File.symlink?(src)
-
-        root = File.realpath(@bundle_dir)
-        !File.realpath(src).start_with?("#{root}/")
-      rescue SystemCallError
-        true
-      end
+      # AssetInstaller.linked? for this bundle's source.
+      def linked?(src) = self.class.linked?(src, @bundle_dir)
 
       # linked? with a "<label> is a symlink (not installed)" warning.
       def linked_out?(src, label)
@@ -338,21 +264,10 @@ module Samagotchi
         true
       end
 
-      # The hook loader skips every hook of a bundle whose requires_chi this
-      # chi doesn't meet (Hooks::BundleLoader); say so at install, as
-      # install_plugin does for the plugin.
-      def warn_hooks_requires_chi
-        return if @manifest.nil? || @bundle_hooks.empty?
-
-        if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, @chi_version))
-          @warnings << "Bundle #{@name}: its hooks won't load: #{failure}"
-        end
-      end
-
       # GuardrailWiring#bundle_rules doesn't read the rules of a bundle whose
       # requires_chi this chi doesn't meet, and a session that never loaded
       # them records a required load failure (the gate refuses guarded calls
-      # until chi is updated): say so at install, as the hooks warning does.
+      # until chi is updated): say so at install, as install_plugin does.
       def warn_rules_requires_chi(rule_files)
         return if @manifest.nil? || rule_files.empty?
 

data/lib/samagotchi/memory_bundle/builder.rb

@@ -4,7 +4,6 @@ require "digest"
 require_relative "file_digest"
 require "fileutils"
 require "tmpdir"
-require_relative "bundle_hook"
 require_relative "manifest"
 require_relative "placeholder"
 require_relative "../memory_paths"
@@ -12,7 +11,9 @@ require_relative "../model_overlay"
 
 module Samagotchi
   module MemoryBundle
-    # Builds local memories and installed hooks into a shareable bundle.
+    # Builds local memories and an installed bundle's rules, plugin and
+    # scripts into a shareable bundle (class-file hooks are retired: an older
+    # record's hooks/ isn't built).
     #
     # Inverse of Installer: reads from the resolved scope directory,
     # computes SHA256 checksums, writes manifest.yml via Manifest.write,
@@ -27,11 +28,10 @@ module Samagotchi
       # record and its dir), else from the scope dir:
       #   record      the InstalledBundle, nil when none is installed (or
       #               it doesn't read)
-      #   hooks       basename => BundleHook; hook_files basename => path
       #   rules       guardrails/*.yml paths
       #   plugin      the installed plugin file, nil without one
       #   scripts     file name => path; context_providers, block_renderers the parsed lists
-      InstalledParts = Data.define(:record, :hooks, :hook_files, :rules, :plugin, :scripts, :context_providers, :block_renderers)
+      InstalledParts = Data.define(:record, :rules, :plugin, :scripts, :context_providers, :block_renderers)
 
       attr_reader :built_files, :warnings, :placeholder_warnings, :out_path, :staging_dir
 
@@ -138,12 +138,10 @@ module Samagotchi
         end
       end
 
-      # The installed bundle's hooks (a recorded one missing on disk left
-      # out; one with no recorded sha gets its file's), guardrail rules,
-      # plugin, scripts, context providers and block renderers (its
-      # InstalledManifest's). Without hooks or rules in a
-      # record, the scope dir's hooks/*.rb and guardrails/*.yml (building
-      # from a raw bundle dir that is also the memories dir).
+      # The installed bundle's guardrail rules, plugin, scripts, context
+      # providers and block renderers (its InstalledManifest's). Without
+      # rules in a record, the scope dir's guardrails/*.yml (building from a
+      # raw bundle dir that is also the memories dir).
       # @return [InstalledParts]
       def installed_parts(name, target_dir)
         prov = nil
@@ -156,23 +154,6 @@ module Samagotchi
           record = nil
         end
 
-        hooks = {}
-        hook_files = {}
-        if record&.hooks&.any?
-          record.hooks.each do |basename, hook|
-            src = File.join(prov.hooks_dir, basename)
-            next unless File.exist?(src)
-
-            hooks[basename] = hook.sha256.empty? ? hook.with(sha256: BundleHook.of_file(src).sha256) : hook
-            hook_files[basename] = src
-          end
-        else
-          Dir.glob(File.join(target_dir, "hooks", "*.rb")).sort.each do |src|
-            hooks[File.basename(src)] = BundleHook.of_file(src)
-            hook_files[File.basename(src)] = src
-          end
-        end
-
         rules_dir = record&.guardrails&.any? ? prov.guardrails_dir : File.join(target_dir, "guardrails")
         plugin = record ? prov.plugin_path(record) : nil
         manifest = record&.manifest
@@ -181,7 +162,7 @@ module Samagotchi
         raise BuildError, "the installed #{name}'s record: #{problem}" if problem
 
         InstalledParts.new(
-          record: record, hooks: hooks, hook_files: hook_files,
+          record: record,
           rules: Dir.exist?(rules_dir) ? Dir.glob(File.join(rules_dir, "*.yml")).sort : [],
           plugin: plugin && File.file?(plugin) ? plugin : nil,
           scripts: installed_scripts(prov, record),
@@ -190,14 +171,10 @@ module Samagotchi
         )
       end
 
-      # The memories, hooks/, guardrails/, the plugin and scripts/ into the
+      # The memories, guardrails/, the plugin and scripts/ into the
       # staging dir, laid out as Installer reads a bundle.
       def stage_files(staging, candidates, parts)
         candidates.each { |src| FileUtils.cp(src, File.join(staging, File.basename(src))) }
-        unless parts.hook_files.empty?
-          FileUtils.mkdir_p(File.join(staging, "hooks"))
-          parts.hook_files.each { |basename, src| FileUtils.cp(src, File.join(staging, "hooks", basename)) }
-        end
         unless parts.rules.empty?
           FileUtils.mkdir_p(File.join(staging, "guardrails"))
           parts.rules.each { |src| FileUtils.cp(src, File.join(staging, "guardrails", File.basename(src))) }
@@ -225,9 +202,9 @@ module Samagotchi
           scope: @scope,
           description: description,
           files: files_map,
-          hooks: parts.hooks.empty? ? nil : parts.hooks,
           trust_level: trust_level,
-          plugin: parts.plugin && { file: File.basename(parts.plugin), sha256: FileDigest.sha256(parts.plugin) },
+          plugin: parts.plugin && { file: File.basename(parts.plugin), sha256: FileDigest.sha256(parts.plugin),
+                                    required: manifest&.plugin_required },
           requires_chi: manifest&.requires_chi,
           needs: manifest&.needs,
           scripts: parts.scripts.transform_values { |src| FileDigest.sha256(src) },

data/lib/samagotchi/memory_bundle/bundle_hook.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "file_digest"
-
 module Samagotchi
   module MemoryBundle
-    # One hook's metadata, as a bundle's manifest.yml declares it and its
-    # installed record (manifest.json) keeps it: the file's sha256
+    # One class-file hook's metadata, as an older chi's installed record
+    # (manifest.json) keeps it (chi no longer installs or loads them:
+    # Manifest::HooksRetired; it reads them to retire, uninstall and name
+    # them, and the trash selection takes #sha256): the file's sha256
     # ("sha256:<hex>", "" when none is recorded), the events it registers
     # for (manifest `event:` for one, `events:` a list; none: it isn't
-    # loaded), on_error (skip, log or fail_closed) and priority. One
-    # instance of the hook serves every event it lists. The one place the
-    # defaults live.
+    # loaded), on_error (skip, log or fail_closed) and priority. The one
+    # place the defaults live.
     class BundleHook < Data.define(:sha256, :events, :on_error, :priority)
       DEFAULT_ON_ERROR = "skip"
       DEFAULT_PRIORITY = 100
@@ -37,35 +36,11 @@ module Samagotchi
             priority: (h["priority"] || DEFAULT_PRIORITY).to_i)
       end
 
-      # A hook known only by its file (no declared event): its sha, the defaults.
-      # Callers pass a file that is there (FileDigest is nil for one that isn't).
-      def self.of_file(path)
-        new(sha256: FileDigest.sha256(path))
-      end
-
       # "sha256:<hex>" from either form, "" for none.
       def self.prefixed(sha)
         sha = sha.to_s.strip
         sha.empty? || sha.start_with?("sha256:") ? sha : "sha256:#{sha}"
       end
-
-      # The sha's hex, "" when none is recorded.
-      def hex = sha256.delete_prefix("sha256:")
-
-      # Whether the hook fails closed: on_error fail_closed applies to its
-      # before_tool_call registration only.
-      def fail_closed?(event) = on_error == "fail_closed" && event.to_s == "before_tool_call"
-
-      # How `chi bundle status` / `diff` name its events: `event=x`, or
-      # `events=x,y` for more than one.
-      def events_field = events.size > 1 ? "events=#{events.join(",")}" : "event=#{events.first}"
-
-      # The string-keyed form manifest.yml and manifest.json hold: `event`
-      # for one event (as an older chi reads it), `events` for more.
-      def to_record
-        listed = events.size > 1 ? { "events" => events.dup } : { "event" => events.first.to_s }
-        { "sha256" => sha256, **listed, "on_error" => on_error, "priority" => priority }
-      end
     end
   end
 end