samagotchi 0.157.0 → 0.158.0

data/lib/samagotchi/memory_bundle/installer.rb

@@ -34,8 +34,9 @@ module Samagotchi
     class Installer
       class InstallError < StandardError; end
 
-      # What the run did to one file (a memory, or a hook, rule, plugin or
-      # script: AssetInstaller writes them too), as #results holds it. word is
+      # What the run did to one file (a memory, or a rule, plugin or script:
+      # AssetInstaller writes them too, and removes an older chi's hooks), as
+      # #results holds it. word is
       # the report bucket (#summary): a real run's (:installed, :updated,
       # :merged, :kept, :kept_pruned, :kept_shared, :kept_own (a file left as
       # the user's), :up_to_date, :conflict, :removed) or a dry run's
@@ -166,8 +167,10 @@ module Samagotchi
         would_install = with_word(:would_install)
         would_update = with_word(:would_update)
         fast_forward = with_word(:fast_forward)
-        removed = with_word(:removed)
-        would_remove = with_word(:would_remove)
+        # An older chi's class-file hooks this run removes: a line of their
+        # own, with why (AssetInstaller#retire_hooks).
+        retired, removed = with_word(:removed).partition { |key| @results[key].note == AssetInstaller::RETIRED }
+        would_retire, would_remove = with_word(:would_remove).partition { |key| @results[key].note == AssetInstaller::RETIRED }
 
         lines << "Installed: #{installed.join(", ")}" unless installed.empty?
         lines << "Updated: #{updated.join(", ")}" unless updated.empty?
@@ -178,6 +181,8 @@ module Samagotchi
         lines << FileStanding.merged_line(would_merge, @manifest&.version, dry_run: true) unless would_merge.empty?
         lines << "Removed (no longer in the bundle): #{removed.join(", ")}#{" (moved to #{trash_dir})" if trash_dir}" unless removed.empty?
         lines << "Would remove (no longer in the bundle): #{would_remove.join(", ")}" unless would_remove.empty?
+        lines << "Removed (#{AssetInstaller::RETIRED}): #{retired.join(", ")}" unless retired.empty?
+        lines << "Would remove (#{AssetInstaller::RETIRED}): #{would_retire.join(", ")}" unless would_retire.empty?
         lines << "Kept (local edits preserved): #{kept.join(", ")}" unless kept.empty?
         lines << "Up to date: #{up_to_date.join(", ")}" unless up_to_date.empty?
         lines << "Skipped: #{skipped.join(", ")}" unless skipped.empty?
@@ -213,11 +218,11 @@ module Samagotchi
       def with_word(*words) = @results.select { |_, result| words.include?(result.word) }.keys
 
       # A plain install over a bundle that is already installed from the same
-      # source: it rewrote the bundle's hooks, rules, plugin, scripts and its
+      # source: it rewrote the bundle's rules, plugin, scripts and its
       # record, and left a memory the user wrote as it was. So the line says
       # what changed, and points at the upgrade for the memories it kept.
       def reinstall_line
-        line = "#{@name} was already installed from #{@source}: its hooks, rules, plugin and scripts " \
+        line = "#{@name} was already installed from #{@source}: its rules, plugin and scripts " \
                "now match it and its record was rewritten"
         # :kept_own is the only way a memory is left out of a plain install
         # (its KEPT_OWN or HELD row): its bytes differ from the bundle's.
@@ -256,10 +261,10 @@ module Samagotchi
       # #ref; a path resolved); one it can't place (an older record's
       # relative path) never refuses.
       #   - a name chi ships comes from a shipped dir only, unless --force
-      #     (install and upgrade): the plugin and hooks it replaces are chi's;
+      #     (install and upgrade): the plugin and rules it replaces are chi's;
       #   - a plain install over a bundle from another source is refused,
       #     --force too (that overwrites files, it doesn't switch sources):
-      #     it would delete the plugin and hooks and rewrite the record;
+      #     it would delete the plugin and rules and rewrite the record;
       #   - an upgrade may switch sources (a URL and a local copy of it are
       #     one bundle, an archive's file name has its version), and
       #     #source_change says so (the summary's first line).
@@ -351,19 +356,32 @@ module Samagotchi
         @bundle_dir = @source_dir = prepared.dir
         @source_owned = prepared.owned
         @source_commit = prepared.commit
+        refuse_hooks
         @manifest = Manifest.read(dir: @bundle_dir)
         clash = @manifest.session_settings_clash
         raise InstallError, clash if clash
       rescue SourceNormalizer::UnknownSourceError => e
         raise InstallError, "Source normalization failed: #{e.message}"
+      rescue Manifest::HooksRetired => e
+        # A rule, not a strictness option: refused strict or not, a dry run too.
+        raise InstallError, e.message
       rescue Manifest::ValidationError => e
         raise InstallError, e.message if @strict
 
         @warnings << "No manifest found — proceeding without strict manifest validation"
       end
 
+      # A source that ships class-file hooks (hooks/*.rb, listed or not) is
+      # refused before its manifest is read; its manifest's hooks: is
+      # Manifest.read's refusal (Manifest::HooksRetired either way).
+      # @raise [Manifest::HooksRetired]
+      def refuse_hooks
+        files = Manifest::HooksRetired.files_in(@bundle_dir)
+        raise Manifest::HooksRetired.for_files(files) unless files.empty?
+      end
+
       # A bundle whose requires_chi this chi doesn't meet is not installed at
-      # all: --force is what installs it, and its plugin, hooks and rules then
+      # all: --force is what installs it, and its plugin and rules then
       # warn that they won't load (AssetInstaller). The words come from
       # Manifest.requires_chi_failure, so the requirement is said one way.
       # A dry run is refused the same way: nothing there would load either.
@@ -555,8 +573,11 @@ module Samagotchi
       # differs from its manifest's sha256. One kept or skipped isn't checked
       # (it takes nothing from the bundle). What is checked is the source
       # file, the bytes the write or merge takes, so a dry run checks what it
-      # would bring in, never the user's bytes on disk.
+      # would bring in, never the user's bytes on disk. A dev install follows
+      # its own tree; chi bundle check flags its stale shas instead.
       def verify_memory_checksums
+        return if @dev
+
         @bundle_md.each do |file_key|
           result = @results[file_key]
           next unless result&.action&.takes_source?
@@ -579,7 +600,7 @@ module Samagotchi
 
       # The install's record (Provenance#write), only with a manifest and
       # not on a dry run. An upgrade with conflicts writes it too: the new
-      # version, the plugin's and hooks' new shas, and the old base for each
+      # version, the plugin's new sha, and the old base for each
       # conflicted file, marked conflict (chi bundle status shows it).
       # Skipping it left the replaced plugin failing its sha check.
       # @param installed [AssetInstaller::Installed]
@@ -589,11 +610,8 @@ module Samagotchi
           scope: @target_scope,
           version: @manifest.version,
           source_path: @source,
-          # AssetInstaller added the discovered hooks/*.rb to manifest.hooks.
-          hooks: @manifest.hooks,
           trust_level: @manifest.trust_level,
           source_commit: @source_commit,
-          hooks_files: installed.hook_files,
           guardrails_files: installed.guardrail_files,
           plugin_file: installed.plugin_file,
           plugin_required: @manifest.plugin&.dig(:required) == true,

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -5,7 +5,6 @@ require "digest"
 require "fileutils"
 require_relative "../context_providers"
 require_relative "../version"
-require_relative "bundle_hook"
 
 module Samagotchi
   autoload :BlockRenderers, File.expand_path("../block_renderers", __dir__)
@@ -66,6 +65,26 @@ module Samagotchi
     class Manifest
       class ValidationError < StandardError; end
 
+      # Class-file bundle hooks (hooks/*.rb, the manifest's hooks:) are
+      # retired: chi installs and loads none. WORDS is the one wording of
+      # it, wherever chi meets one (the Engine's first-turn line, install,
+      # chi bundle check and status, chi update's row). A strict read of a
+      # manifest with a hooks: entry raises it (.for_key's message); a
+      # tolerant read (a kept manifest.yml) ignores the key.
+      class HooksRetired < ValidationError
+        WORDS = "class-file bundle hooks are retired: chi loads no hooks/*.rb; a bundle hooks events from its " \
+                "plugin.rb with chi.on, see docs/plugins.md"
+
+        # The manifest's hooks: key.
+        def self.for_key = new("hooks: #{WORDS}")
+
+        # A source's hooks/*.rb (+files+, relative), with or without the key.
+        def self.for_files(files) = new("#{files.join(", ")}: #{WORDS}")
+
+        # The source's hooks/*.rb, relative and sorted ([] for none).
+        def self.files_in(dir) = Dir.glob(File.join(dir, "hooks", "*.rb")).map { |f| "hooks/#{File.basename(f)}" }.sort
+      end
+
       # A plugin file is a plain .rb name in the bundle's top directory.
       PLUGIN_FILE = /\A[A-Za-z0-9_][A-Za-z0-9_.-]*\.rb\z/
       # A script is a plain file name in the bundle's scripts/.
@@ -88,7 +107,7 @@ module Samagotchi
       # admits a chi that never saw the key. A key the first tag (v0.2.0)
       # already reads has no entry. `files.description` is a files: entry given
       # as a mapping, `*.types` a session_settings:/settings: given as a mapping
-      # of keys to types, `hooks.events` a hook entry with an events: list. A key
+      # of keys to types. A key
       # whose release is not out yet waits here as a comment naming it, the way
       # Plugin::Api::SINCE does, until `release:bump` gives it its version
       # (docs/releasing.md).
@@ -100,16 +119,14 @@ module Samagotchi
         "session_settings" => "0.84.0",
         "session_settings.types" => "0.92.0",
         "settings.types" => "0.92.0",
-        "hooks.events" => "0.98.0",
         "settings" => "0.143.0",
         "block_renderers" => "0.151.0",
         "plugin.required" => "0.157.0"
       }.freeze
 
       # files: name → "sha256:<hex>" (both forms); file_descriptions: name →
-      # the description a mapping gave, for the files that have one; hooks:
-      # name → BundleHook.
-      attr_reader :name, :version, :scope, :description, :files, :file_descriptions, :hooks, :trust_level, :plugin, :requires_chi, :needs, :includes,
+      # the description a mapping gave, for the files that have one.
+      attr_reader :name, :version, :scope, :description, :files, :file_descriptions, :trust_level, :plugin, :requires_chi, :needs, :includes,
                   :scripts, :context_providers, :block_renderers, :session_settings, :session_setting_types, :settings, :setting_types, :unknown_keys
 
       def initialize(path:)
@@ -131,7 +148,8 @@ module Samagotchi
         @scope    = normalize_scope(raw["scope"])
         @description = (raw["description"] || "").to_s
         @files    = parse_files(raw["files"] || {})
-        @hooks    = parse_hooks(raw["hooks"] || {})
+        raise HooksRetired.for_key if self.class.lists_hooks?(raw["hooks"])
+
         @file_descriptions = parse_file_descriptions(raw["files"])
         @trust_level = (raw["trust_level"] || "experimental").to_s
         @plugin = parse_plugin(raw["plugin"])
@@ -170,8 +188,8 @@ module Samagotchi
       # chi (a newer chi tightened it, or an older one wrote it) costs only
       # that key, which reads as empty with its message in the problems:
       #   name, version (never checked: identity is the record's), scope;
-      #   files and their descriptions, scripts, plugin; hooks (one bad entry
-      #   fails the whole key); needs, context_providers; block_renderers
+      #   files and their descriptions, scripts, plugin (hooks: is ignored,
+      #   HooksRetired); needs, context_providers; block_renderers
       #   (against +fallback_scripts+ when scripts: failed); includes (after
       #   what its check reads); session_settings with its types, settings
       #   with theirs (one raw value each, so one problem); requires_chi,
@@ -186,6 +204,10 @@ module Samagotchi
         [manifest, manifest.send(:read_tolerantly, path, fallback_scripts)]
       end
 
+      # Whether a manifest's hooks: value lists anything (none, {} and []
+      # don't: a manifest may keep an empty key).
+      def self.lists_hooks?(raw) = !(raw.nil? || ((raw.is_a?(Hash) || raw.is_a?(Array)) && raw.empty?))
+
       def self.read(dir:)
         manifest_path = File.join(dir, "manifest.yml")
         raise ValidationError, "manifest.yml not found in #{dir}" unless File.exist?(manifest_path)
@@ -204,13 +226,6 @@ module Samagotchi
         hex unless hex.nil? || hex.empty?
       end
 
-      # Returns sha256 hex for a hook basename (e.g. "guardrails.rb"), nil
-      # when it declares none (nothing to verify).
-      def checksum_for_hook(basename)
-        hex = @hooks[basename]&.hex
-        hex unless hex.nil? || hex.empty?
-      end
-
       # @return [String, nil] the plugin's sha256 hex, "sha256:" stripped
       def checksum_for_plugin
         sha = @plugin && @plugin[:sha256].to_s
@@ -242,8 +257,8 @@ module Samagotchi
 
       # The SINCE keys this manifest actually uses, each with the chi release
       # that first read it: the plain keys, and the shapes only a newer chi
-      # reads — a files: entry given as a mapping, a hook entry with an events:
-      # list, a session_settings:/settings: given as a mapping of keys to types.
+      # reads — a files: entry given as a mapping, a session_settings:/settings:
+      # given as a mapping of keys to types.
       # @return [Hash{String => String}]
       def floor_keys
         raw = @raw
@@ -258,15 +273,12 @@ module Samagotchi
         found["files.description"] = SINCE["files.description"] if raw["files"].is_a?(Hash) && raw["files"].values.any?(Hash)
         found["session_settings.types"] = SINCE["session_settings.types"] if raw["session_settings"].is_a?(Hash)
         found["settings.types"] = SINCE["settings.types"] if raw["settings"].is_a?(Hash)
-        if raw["hooks"].is_a?(Hash) && raw["hooks"].values.any? { |entry| entry.is_a?(Hash) && entry.key?("events") }
-          found["hooks.events"] = SINCE["hooks.events"]
-        end
         found
       end
 
       # Writes a fresh manifest.yml from computed checksums at `dir`.
       # +file_descriptions+ (name → text) writes those files as mappings.
-      def self.write(dir:, name:, version:, files:, scope: nil, description: "", hooks: nil, trust_level: nil,
+      def self.write(dir:, name:, version:, files:, scope: nil, description: "", trust_level: nil,
                      plugin: nil, requires_chi: nil, needs: nil, scripts: {}, context_providers: [], block_renderers: [], file_descriptions: {},
                      session_settings: [], session_setting_types: {}, settings: nil, setting_types: {})
         FileUtils.mkdir_p(dir)
@@ -280,7 +292,6 @@ module Samagotchi
           text = file_descriptions[key].to_s.strip
           [key, text.empty? ? sha : { "sha256" => sha, "description" => text }]
         end
-        manifest["hooks"] = hooks.to_h { |k, v| [k.to_s, BundleHook.parse(v).to_record] } if hooks && !hooks.empty?
         manifest["trust_level"] = trust_level.to_s if trust_level && !trust_level.to_s.empty?
         if plugin
           sha = plugin[:sha256].to_s
@@ -389,7 +400,7 @@ module Samagotchi
         end
         @scripts = tolerate(problems, "scripts", {}) { parse_scripts(raw["scripts"]) }
         @plugin = tolerate(problems, "plugin", nil) { parse_plugin(raw["plugin"]) }
-        @hooks = tolerate(problems, "hooks", {}) { parse_hooks(raw["hooks"] || {}) }
+        # An old kept manifest's hooks: is no problem: it isn't read (HooksRetired).
         @needs = tolerate(problems, "needs", []) { self.class.parse_needs(raw["needs"]) }
         @context_providers = tolerate(problems, "context_providers", []) { parse_context_providers(raw["context_providers"]) }
         script_names = problems.key?("scripts") ? fallback_scripts.map(&:to_s) : @scripts.keys
@@ -546,8 +557,8 @@ module Samagotchi
 
           name
         end.uniq
-        if !names.empty? && (!@files.empty? || !@hooks.empty? || @plugin || !@scripts.empty?)
-          raise ValidationError, "a bundle with includes: holds only its includes (no files, hooks, plugin or scripts)"
+        if !names.empty? && (!@files.empty? || @plugin || !@scripts.empty?)
+          raise ValidationError, "a bundle with includes: holds only its includes (no files, plugin or scripts)"
         end
 
         names
@@ -559,34 +570,6 @@ module Samagotchi
         text = raw.to_s.strip
         text.empty? ? nil : text
       end
-
-      def parse_hooks(raw)
-        return {} unless raw.is_a?(Hash)
-
-        raw.each_with_object({}) do |(k, v), acc|
-          next unless k.is_a?(String) && !k.empty?
-          next unless v.is_a?(Hash)
-
-          check_hook_events(k, v)
-          acc[k] = BundleHook.parse(v)
-        end
-      end
-
-      HOOK_EVENT_NAME = /\A[a-z][a-z0-9_]*\z/
-
-      # A hook's events: list holds event names (one instance registered
-      # for each); it and event: are one or the other.
-      def check_hook_events(file, entry)
-        return unless entry.key?("events")
-
-        raw = entry["events"]
-        raise ValidationError, "hooks: #{file}: give event: or events:, not both" if entry.key?("event")
-        raise ValidationError, "hooks: #{file}: events: must be a list of event names" unless raw.is_a?(Array) && !raw.empty?
-
-        raw.each do |item|
-          raise ValidationError, "hooks: #{file}: events: #{item.inspect} is not an event name" unless item.is_a?(String) && item.strip.match?(HOOK_EVENT_NAME)
-        end
-      end
     end
   end
 end

data/lib/samagotchi/memory_bundle/provenance.rb

@@ -8,7 +8,6 @@ require "tmpdir"
 require_relative "../atomic_file"
 require_relative "../memory_paths"
 require_relative "../version"
-require_relative "bundle_hook"
 require_relative "file_digest"
 require_relative "installed_bundle"
 require_relative "manifest"
@@ -195,7 +194,6 @@ module Samagotchi
       #   the record. nil keeps an entry with no base (a kept edit that has
       #   none: the user's file must never become it), with its recorded
       #   checksum.
-      # @param hooks_files [Hash] basename => path for hook file snapshots (optional)
       # @param guardrails_files [Hash] basename => installed rule file; the
       #   sha256 of each is recorded (the Engine checks it at load)
       # @param plugin_file [String, nil] the installed plugin file; its name
@@ -229,7 +227,9 @@ module Samagotchi
       #   (requires_chi … setting_types) are still written from the kwargs:
       #   an older chi sharing this memories dir reads only them
       #   (docs/internals/bundles.md); a key a later manifest gains is never added
-      def write(files:, scope:, version:, source_path:, hooks: {}, trust_level: nil, source_commit: nil, hooks_files: {},
+      # The record has no hooks ("hooks" => {}: class-file hooks are retired)
+      # and an older record's hook bases go.
+      def write(files:, scope:, version:, source_path:, trust_level: nil, source_commit: nil,
                 guardrails_files: {}, plugin_file: nil, plugin_required: false, requires_chi: nil, needs: nil, marks: [], incoming_dir: nil, includes: nil,
                 scripts_files: {}, context_providers: [], block_renderers: [], file_descriptions: {}, session_settings: [], session_setting_types: {}, settings: nil, setting_types: {},
                 dev: false, manifest_from: nil)
@@ -275,40 +275,8 @@ module Samagotchi
           end
         end
 
-        # Hooks provenance: persist metadata and base snapshots for hooks
-        hooks_map = {}
-        # Incoming hooks: basename => BundleHook (or its metadata hash)
-        normalized_hooks = {}
-        if hooks.is_a?(Hash)
-          hooks.each do |k, v|
-            next unless k.is_a?(String) && !k.empty?
-            next unless v.is_a?(Hash) || v.is_a?(BundleHook)
-
-            normalized_hooks[k] = BundleHook.parse(v)
-          end
-        end
-        # Prune stale hook bases
-        existing&.hooks&.each_key do |old_key_str|
-          FileUtils.rm_f(File.join(bases_dir, old_key_str)) unless normalized_hooks.key?(old_key_str)
-        end
-        # Save base snapshots for hooks where a file path was provided, and
-        # record the sha256 of the installed file itself: the load-time check
-        # compares against it, and a declared sha can be wrong (installing
-        # only warns about that).
-        hooks_files = {} unless hooks_files.is_a?(Hash)
-        normalized_hooks.each do |k, hook|
-          src = hooks_files[k] || hooks_files[k.to_sym]
-          hook = hook.with(sha256: BundleHook.of_file(src.to_s).sha256) if src && File.exist?(src.to_s)
-          hook = hook.with(sha256: DEV_SHA) if dev
-          hooks_map[k] = hook.to_record
-          next unless src && File.exist?(src.to_s)
-
-          begin
-            File.write(File.join(bases_dir, k), File.read(src.to_s))
-          rescue StandardError
-            nil
-          end
-        end
+        # An older chi's hooks: their bases go with them (AssetInstaller#retire_hooks).
+        existing&.hooks&.each_key { |old_key_str| FileUtils.rm_f(File.join(bases_dir, old_key_str)) }
 
         manifest_data = {
           "name" => @name,
@@ -317,7 +285,7 @@ module Samagotchi
           "source" => source_path.to_s,
           "installed_at" => DateTime.now.iso8601,
           "files" => merged_entries,
-          "hooks" => hooks_map
+          "hooks" => {}
         }
         manifest_data["dev"] = true if dev
         if guardrails_files.is_a?(Hash) && !guardrails_files.empty?
@@ -460,7 +428,7 @@ module Samagotchi
       # wrote it, or the file is gone), when +dir+ is the source of what's
       # installed: its manifest names this bundle at the recorded version and
       # says what the record keeps (#manifest_difference), and every sha the
-      # record has for a memory, plugin, hook, script or rule is the source
+      # record has for a memory, plugin, script or rule is the source
       # file's. Then the file is copied to #kept_manifest_path and the
       # record gains its manifest_sha, and nothing else changes (installed_at,
       # the mirror, installed_by). A dev record is never adopted: its next
@@ -585,8 +553,8 @@ module Samagotchi
       # The first manifest key in which +manifest+ says other than what the
       # record keeps, nil when none: each mirrored key as #write records it (one
       # the record lacks is fine only when an older chi couldn't have known it:
-      # Manifest::SINCE has it), then each recorded hook's events, on_error and
-      # priority.
+      # Manifest::SINCE has it). An older record's hooks don't count: they
+      # no longer load, and the source can't list any (Manifest::HooksRetired).
       def manifest_difference(bundle, manifest)
         recorded = plain(bundle.mirror)
         source = plain(self.class.mirror_fields(
@@ -595,18 +563,11 @@ module Samagotchi
           session_settings: manifest.session_settings, session_setting_types: manifest.session_setting_types,
           settings: manifest.settings, setting_types: manifest.setting_types
         ))
-        differing = InstalledBundle::MIRROR_KEYS.find do |key|
+        InstalledBundle::MIRROR_KEYS.find do |key|
           next false if recorded[key] == source[key]
 
           !(recorded[key].nil? && Manifest::SINCE.key?(MIRROR_SINCE.fetch(key, key)))
         end
-        return differing if differing
-
-        same_hooks = bundle.hooks.all? do |file, hook|
-          theirs = manifest.hooks.fetch(file, BundleHook.new)
-          [hook.events, hook.on_error, hook.priority] == [theirs.events, theirs.on_error, theirs.priority]
-        end
-        same_hooks ? nil : "hooks"
       end
       private :manifest_difference
 
@@ -614,7 +575,7 @@ module Samagotchi
       private :plain
 
       # Each file the record has a sha for, by its path in the bundle's source
-      # => that sha: the plugin, hooks, scripts, rules, and each memory whose
+      # => that sha: the plugin, scripts, rules, and each memory whose
       # entry has a checksum and no conflict mark (its base is the bundle's text).
       def installed_shas(bundle, manifest)
         shas = bundle.files.each_with_object({}) do |(key, entry), acc|
@@ -624,7 +585,6 @@ module Samagotchi
           file = manifest.plugin && manifest.plugin[:file].to_s
           shas[file && File.basename(file) == bundle.plugin.file ? file : bundle.plugin.file] = bundle.plugin.sha256
         end
-        bundle.hooks.each { |file, hook| shas["hooks/#{file}"] = hook.sha256 }
         bundle.scripts.each { |file, sha| shas["scripts/#{file}"] = sha }
         bundle.guardrails.each { |file, sha| shas["guardrails/#{file}"] = sha }
         shas

data/lib/samagotchi/memory_bundle/remerge.rb

@@ -4,6 +4,7 @@ require_relative "index_updater"
 require_relative "manifest"
 require_relative "memory_files"
 require_relative "file_actions"
+require_relative "file_digest"
 require_relative "merger"
 require_relative "provenance"
 require_relative "trash"
@@ -77,7 +78,8 @@ module Samagotchi
         @behind = []
         @warnings = []
         @trash = Trash.new(@name)
-        shipped = MemoryFiles.select(@source_dir, Manifest.read(dir: @source_dir))
+        @manifest = Manifest.read(dir: @source_dir)
+        shipped = MemoryFiles.select(@source_dir, @manifest)
         marked.each { |key, entry| retry_file(key, entry, shipped) }
         settle unless dry_run
         Result.new(merged: @merged, settled: @settled, stamped: @stamped.map(&:file), behind: @behind, warnings: @warnings, trash_copy: @trash.copy_line)
@@ -111,7 +113,7 @@ module Samagotchi
       def retry_row(key, entry, state, action)
         decision = view.decision(key, state) if action.do == :decide || action.behind?
         action = FileActions.decided(decision.outcome, :remerge) if action.do == :decide
-        if action.do == :merge then merge_file(key, entry, decision.outcome)
+        if action.do == :merge then merge_file(key, entry, state, decision.outcome)
         elsif action.behind?
           waits = decision.outcome.status == :fast_forward
           mark(key, entry, waits ? behind_for(key, FileStanding::WAITS_FOR_UPGRADE) : view.behind(key, decision.outcome, @record.version))
@@ -141,7 +143,9 @@ module Samagotchi
         @stamped << behind unless entry[:incoming_sha] && @record.behind_entry(key, entry) == behind && File.exist?(@provenance.incoming_path(key))
       end
 
-      def merge_file(key, entry, outcome)
+      def merge_file(key, entry, state, outcome)
+        warning = FileDigest.mismatch(key, state.paths[:incoming], @manifest.checksum_for(key))
+        @warnings << warning if warning
         return @merged << key if @dry_run
         return @merged << key if Merger.write_merged(view.paths(key)[:current], outcome, @trash)
 

data/lib/samagotchi/memory_bundle/shas.rb

@@ -14,7 +14,7 @@ module Samagotchi
 
       # A sha line that doesn't match its file: +old+ is the hex the line
       # holds ("" for a placeholder `sha256: sha256:`), nil when the entry
-      # has no sha line at all (a plugin:, hooks: or scripts: entry the
+      # has no sha line at all (a plugin: or scripts: entry the
       # installer then takes unchecked; .refresh can't write one).
       Stale = Data.define(:file, :old, :new)
 
@@ -30,7 +30,6 @@ module Samagotchi
       # names, the layout otherwise untouched. The shapes:
       #   files:            a.md: sha256:<hex>             (dir/a.md)
       #                     a.md:\n    sha256: sha256:<hex> (dir/a.md, with description:)
-      #   hooks:            h.rb:\n    sha256: sha256:<hex> (dir/hooks/h.rb)
       #   plugin:           file: p.rb\n  sha256: sha256:<hex> (dir/p.rb)
       #   scripts:          s.rb: sha256:<hex>             (dir/scripts/s.rb)
       # Returns [text, [[relative file, old sha, new sha], ...]] for the lines
@@ -43,8 +42,9 @@ module Samagotchi
         [text, changes]
       end
 
-      # The stale sha lines of the bundle at +dir+, then the plugin:, hooks:
-      # and scripts: entries with no sha line, as [Stale].
+      # The stale sha lines of the bundle at +dir+, then the plugin: and
+      # scripts: entries with no sha line, as [Stale]. (A hooks: key, which
+      # chi refuses, has no sha lines here.)
       def stale(dir, text = File.read(File.join(dir, "manifest.yml")))
         _, changes, unlined = scan(dir, text)
         changes.map { |file, old, new| Stale.new(file, old, new) } +
@@ -86,11 +86,10 @@ module Samagotchi
       # take a placeholder (`chi bundle check`) parse this text.
       def parseable(text) = text.gsub(/^(\s*(?:["']?[^"':\s][^"':]*["']?: )?)sha256:(?=[ \t]*(?:#[^\r\n]*)?\r?$)/, "\\1sha256:0")
 
-      # The code files the manifest names (plugin, hooks, scripts), as paths
+      # The code files the manifest names (plugin, scripts), as paths
       # relative to the bundle dir.
       def coded(parsed, plugin_file)
         (plugin_file.is_a?(String) ? [plugin_file] : []) +
-          keys(parsed["hooks"]).map { |h| File.join("hooks", h) } +
           keys(parsed["scripts"]).map { |s| File.join("scripts", s) }
       end
       private_class_method :coded
@@ -114,8 +113,6 @@ module Samagotchi
         when "files"
           m = line.match(/\A(    sha256: )sha256:\h*#{TAIL}/) and return sub && [sub.delete("\"'"), m[1]]
           m = line.match(/\A(  ["']?([^"':]+)["']?: )sha256:\h*#{TAIL}/) and [m[2], m[1]]
-        when "hooks"
-          m = line.match(/\A(    sha256: )sha256:\h*#{TAIL}/) and sub and [File.join("hooks", sub.delete("\"'")), m[1]]
         when "plugin"
           m = line.match(/\A(  sha256: )sha256:\h*#{TAIL}/) and plugin_file and [plugin_file, m[1]]
         when "scripts"