samagotchi 0.157.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,18 +63,16 @@ 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
 
       # Whether the bundle file +src+ reads through a symlink: it is one, or
@@ -91,99 +91,28 @@ module Samagotchi
 
       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}")
-
-          @bundle_hooks << basename
-          install_hook(basename, src) if File.exist?(src)
-        end
-      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)
-        result = result_for(src, dest, updated: @upgrade && @existing)
-        return @results[basename] = planned(result) if @dry_run
-
-        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"
+      # 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
+        return if @dry_run
 
-        FileUtils.mkdir_p(@provenance.hooks_dir)
-        @trash.copy_edit(dest, as: "hooks/#{basename}", recorded: prev_sha, incoming: src)
-        place(src, dest)
-        @results[basename] = result
-        @hook_files[basename] = dest
+        @trash.copy_edits(dir, "hooks", @existing&.hooks&.transform_values(&:sha256))
+        FileUtils.rm_rf(dir)
       end
 
-      # 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] = Installer::FileResult.new(word: :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] = Installer::FileResult.new(word: :installed)
-            @hook_files[basename] = dest
-          end
-        end
-      end
-
-      # 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
-      end
-
-      # Strict mode: a hook whose sha256 differs from the one its manifest
-      # declares warns (as verify_memory_checksums does). The bundle's file is
-      # checked, the one the install copies, so a dry run checks what it
-      # would install, not the old hook in place.
-      def verify_hook_checksums
-        @bundle_hooks.each do |basename|
-          next if @conflicts.key?(basename)
-
-          warning = FileDigest.mismatch("hook #{basename}", File.join(@bundle_dir, "hooks", basename),
-                                        @manifest.checksum_for_hook(basename))
-          @warnings << warning if warning
-        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
@@ -289,22 +218,24 @@ module Samagotchi
 
       # 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) or installed. A dry run records #planned of it, so the two
+      # 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 then :updated
+               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, or the
-      # up to date result as it is (nothing would be written).
+      # 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
@@ -333,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,7 +202,6 @@ 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),
                                     required: manifest&.plugin_required },

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

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -119,7 +119,7 @@ module Samagotchi
       # recorded is gone (:missing). false with no dir.
       def manifest_unkept? = !dir.nil? && (manifest_sha.to_s.empty? || !File.file?(kept_manifest_path))
 
-      # What its manifest says (requires_chi, hook metadata, needs, providers,
+      # What its manifest says (requires_chi, needs, providers,
       # renderers, settings…): the one way to read manifest data of an
       # installed bundle.
       # @return [InstalledManifest]

data/lib/samagotchi/memory_bundle/installed_copy.rb

@@ -3,27 +3,28 @@
 require "fileutils"
 require "tmpdir"
 require "yaml"
-require_relative "bundle_hook"
 require_relative "manifest"
 require_relative "provenance"
 
 module Samagotchi
   module MemoryBundle
-    # An installed bundle laid out as a source folder again: the plugin, hooks,
+    # An installed bundle laid out as a source folder again: the plugin,
     # rules and scripts as they are installed (a dev install's links
     # followed), the memories as their bases (the bundle's bytes, not the
     # user's edits). A bundle's source may be gone or be a URL; this is what
     # `chi update` can check of what really runs.
     #
-    # manifest.yml: its files:, hooks:, plugin: and scripts: are the record's
-    # and the copy's (what is installed: a memory the install left out, or one
-    # with no base, and a manifest hook the record lacks aren't listed, so the
-    # check finds no missing-file for them). Every other key is the kept
+    # manifest.yml: its files:, plugin: and scripts: are the record's and
+    # the copy's (what is installed: a memory the install left out, or one
+    # with no base, isn't listed, so the check finds no missing-file for it).
+    # It has no hooks: and no hooks/, whatever the record or the kept
+    # manifest says: class-file hooks don't load (InstalledCheck names a
+    # record's once). Every other key is the kept
     # manifest.yml's when it is read (InstalledManifest origin :kept), so the
     # check sees its unknown keys too; else the record's mirror's.
     #
     # The shas are the files' own, so an edited plugin is checked as written.
-    # A plugin, hook or script the record lists that isn't there stays
+    # A plugin or script the record lists that isn't there stays
     # listed, for the check's missing-file.
     module InstalledCopy
       module_function
@@ -45,7 +46,7 @@ module Samagotchi
           dir: dir, name: bundle.name, version: bundle.version.to_s.empty? ? "0" : bundle.version, trust_level: manifest.trust_level,
           files: memories(bundle, provenance, dir),
           file_descriptions: manifest.file_descriptions,
-          hooks: hooks(bundle, provenance, dir), plugin: plugin(bundle, provenance, dir),
+          plugin: plugin(bundle, provenance, dir),
           scripts: copies(bundle.scripts, provenance.scripts_dir, File.join(dir, "scripts")),
           requires_chi: manifest.requires_chi, needs: manifest.needs,
           context_providers: manifest.context_providers, block_renderers: manifest.block_renderers,
@@ -57,7 +58,8 @@ module Samagotchi
       end
       private_class_method :write
 
-      # What is installed, which the copy's manifest.yml takes from the record.
+      # What is installed, which the copy's manifest.yml takes from the
+      # record (hooks: none, so the kept manifest's isn't taken either).
       INSTALLED_KEYS = %w[name version files hooks plugin scripts].freeze
 
       # The written manifest's INSTALLED_KEYS and +failed+ keys (the value
@@ -80,15 +82,6 @@ module Samagotchi
       end
       private_class_method :memories
 
-      # The recorded hooks with the metadata they load with (InstalledManifest#hooks).
-      def hooks(bundle, provenance, dir)
-        bundle.manifest.hooks.to_h do |file, hook|
-          sha = copy(File.join(provenance.hooks_dir, file), File.join(dir, "hooks", file), hook.sha256)
-          [file, hook.with(sha256: sha)]
-        end
-      end
-      private_class_method :hooks
-
       def plugin(bundle, provenance, dir)
         return nil unless bundle.plugin
 

data/lib/samagotchi/memory_bundle/installed_manifest.rb

@@ -39,9 +39,6 @@ module Samagotchi
     #
     #   requires_chi, trust_level   the strings as recorded, nil when none
     #   description                 the kept manifest's, nil from the record
-    #   hooks                       basename => BundleHook: each recorded hook,
-    #                               the kept manifest's events, on_error and
-    #                               priority with the record's sha
     #   needs                       Manifest.parse_needs'
     #   script_names                the scripts/ files it lists
     #   context_providers           Array<ContextProviders::Provider>
@@ -61,7 +58,7 @@ module Samagotchi
     #   floor_keys                  the kept manifest's Manifest#floor_keys (key =>
     #                               the first chi that read it), {} from the record
     #   origin                      :kept or :record
-    class InstalledManifest < Data.define(:name, :version, :requires_chi, :trust_level, :description, :hooks, :needs,
+    class InstalledManifest < Data.define(:name, :version, :requires_chi, :trust_level, :description, :needs,
                                           :script_names, :context_providers, :block_renderers, :session_settings,
                                           :session_setting_types, :settings, :setting_types, :file_descriptions,
                                           :plugin_required, :includes, :unknown_keys, :floor_keys, :problems, :origin)
@@ -130,7 +127,6 @@ module Samagotchi
         new(name: bundle.name, version: bundle.version,
             requires_chi: pick.call("requires_chi", kept.requires_chi, mirrored.requires_chi),
             trust_level: kept.trust_level, description: kept.description.empty? ? nil : kept.description,
-            hooks: pick.call("hooks", kept_hooks(bundle.hooks, kept.hooks), bundle.hooks),
             needs: pick.call("needs", kept.needs, mirrored.needs),
             script_names: pick.call("scripts", kept.scripts.keys, mirrored.script_names),
             context_providers: pick.call("context_providers", kept.context_providers, mirrored.context_providers),
@@ -150,21 +146,11 @@ module Samagotchi
         {}
       end
 
-      # Each recorded hook (what is installed): the kept manifest's metadata
-      # for it with the record's sha; one the manifest doesn't list (a found
-      # hooks/*.rb) as recorded. A manifest hook the record lacks isn't installed.
-      def self.kept_hooks(recorded, declared)
-        recorded.to_h do |file, hook|
-          [file, declared.key?(file) ? declared[file].with(sha256: hook.sha256) : hook]
-        end
-      end
-
       def self.from_record(bundle)
         raw = recorded(bundle)
         problems = {}
         new(name: bundle.name, version: bundle.version,
             requires_chi: raw["requires_chi"]&.to_s, trust_level: raw["trust_level"]&.to_s, description: nil,
-            hooks: bundle.hooks,
             needs: parsed(problems, "needs", [], Manifest::ValidationError) { Manifest.parse_needs(raw["needs"]) },
             script_names: bundle.scripts.keys,
             context_providers: parsed(problems, "context_providers", []) { ContextProviders.parse_list(raw["context_providers"]) },
@@ -204,7 +190,7 @@ module Samagotchi
           acc[key] = text unless text.empty?
         end
       end
-      private_class_method :deep_freeze, :kept_stat, :build, :standing, :from_kept, :floors, :kept_hooks, :from_record, :recorded, :parsed,
+      private_class_method :deep_freeze, :kept_stat, :build, :standing, :from_kept, :floors, :from_record, :recorded, :parsed,
                            :list, :types, :file_descriptions
 
       # Why the kept manifest.yml wasn't read: :missing, :stale or :edited (the class