samagotchi 0.157.0 → 0.159.0

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"

data/lib/samagotchi/memory_bundle/shipped_update.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "asset_installer"
+require_relative "asset_state"
 require_relative "installer"
 require_relative "listing"
 require_relative "manifest"
@@ -27,11 +28,12 @@ module Samagotchi
     # bundle that isn't installed and never downgrades.
     #
     # .md files take the Installer's 3-way merge: a clean text merge replaces
-    # the file (merged), a real conflict keeps the user's (behind). Hooks, rules,
-    # the plugin and scripts are replaced; an edited one (Trash.edit?: its
-    # bytes neither the recorded sha, none recorded counting as edited, nor
-    # the incoming file's) is copied to the trash first and listed in
-    # replaced (#trash_bound).
+    # the file (merged), a real conflict keeps the user's (behind). Rules,
+    # the plugin and scripts are replaced, an older chi's hooks removed; an
+    # edited one (AssetState#edited?, Trash.edit?'s rule: its bytes neither
+    # the recorded sha, none recorded counting as edited, nor the incoming
+    # file's) is copied to the trash first and listed in replaced
+    # (#trash_bound).
     #
     # A profile (a shipped meta bundle) is updated through Profile: its row
     # is :would_update when the shipped version is newer or it has members
@@ -119,10 +121,7 @@ module Samagotchi
           r.merged = installer.merged_files
           r.behind = installer.behind
           r.trash_copy = installer.trash_copy_line
-          # The integrity check's warnings; the rest of the Installer's say
-          # what the row's merged and behind already do.
-          mismatches = installer.warnings.grep(/\AChecksum mismatch/)
-          r.note = mismatches.join("; ") unless mismatches.empty?
+          r.note = mismatch_note(installer)
         end
       rescue StandardError => e
         row.dup.tap do |r|
@@ -202,6 +201,10 @@ module Samagotchi
         if Manifest.requires_chi_failure(manifest.requires_chi, chi_version)
           return skip(row, "needs chi #{manifest.requires_chi}", keep_to: true)
         end
+
+        # The upgrade would refuse it (Installer#refuse_hooks).
+        hooks = Manifest::HooksRetired.files_in(row.source_dir)
+        return skip(row, Manifest::HooksRetired.for_files(hooks).message, keep_to: true) unless hooks.empty?
         return skip(row, "project scope: chi bundle upgrade #{ship.source} in the project") if row.scope == "project"
         return skip(row, "unknown scope #{row.scope}: upgrade chi or reinstall") unless MemoryPaths.scope_dir(row.scope)
 
@@ -210,6 +213,7 @@ module Samagotchi
         row.behind = forecast.behind
         row.replaced = trash_bound(name, bundle, manifest, row.source_dir)
         row.status = :would_update
+        row.note = planned_mismatch_note(row)
         row
       rescue SystemCallError => e
         # A file it can't read: the upgrade would fail on it, so this is that
@@ -242,6 +246,20 @@ module Samagotchi
 
       def note_of(remerged) = remerged.warnings.empty? ? nil : remerged.warnings.join("; ")
 
+      def mismatch_note(installer)
+        mismatches = installer.warnings.grep(/\AChecksum mismatch/)
+        mismatches.join("; ") unless mismatches.empty?
+      end
+
+      def planned_mismatch_note(row)
+        installer = Installer.new(source: row.source_dir, name: row.name, scope: row.scope, strict: true, upgrade: true, dry_run: true,
+                                  shipped_dir: File.dirname(row.source_dir))
+        installer.run
+        mismatch_note(installer)
+      rescue Installer::InstallError
+        nil
+      end
+
       def profile_row(row, bundle, shipped_dir, chi_version)
         manifest = Manifest.read(dir: row.source_dir)
         newer = Listing.newer?(row.to, row.from)
@@ -277,49 +295,31 @@ module Samagotchi
       end
 
       # What the upgrade from +source_dir+ copies to the trash, as
-      # hooks/F, guardrails/F, plugin/F, scripts/F: Trash.edit? over the files
-      # AssetInstaller replaces or removes, each against the file it puts in
-      # its place. Hooks: the ones install_hooks copies (listed, else every
-      # hooks/*.rb; present, not links) and the ones prune_dropped_hooks
-      # removes (recorded, no longer shipped; no incoming). Rules, the plugin
-      # and scripts: their whole folder, which the upgrade replaces.
+      # hooks/F, guardrails/F, plugin/F, scripts/F. Rules, the plugin and
+      # scripts: each file of the folders AssetInstaller replaces, against the
+      # one it puts in its place, that is AssetState#edited? (the upgrade's
+      # save_first: the same files, the same rule). hooks/: an older chi's,
+      # which the upgrade removes whole (AssetInstaller#retire_hooks; no
+      # incoming): Trash.edits over it.
       def trash_bound(name, bundle, manifest, source_dir)
         provenance = Provenance.new(name: name)
         rules = Dir.glob(File.join(source_dir, "guardrails", "*.yml")).sort
                    .reject { |file| AssetInstaller.linked?(file, source_dir) }
         plugin = manifest.plugin ? { manifest.plugin[:file] => File.join(source_dir, manifest.plugin[:file]) } : {}
         scripts = manifest.scripts.keys.to_h { |file| [file, File.join(source_dir, "scripts", file)] }
-        trash_bound_hooks(provenance, bundle, manifest, source_dir) +
-          Trash.edits(provenance.guardrails_dir, "guardrails", bundle.guardrails, rules.to_h { |file| [File.basename(file), file] }) +
-          Trash.edits(provenance.plugin_dir, "plugin", bundle.plugin_shas, plugin) +
-          Trash.edits(provenance.scripts_dir, "scripts", bundle.scripts, scripts)
-      end
-
-      # #trash_bound's hooks: AssetInstaller#install_hooks' set (incoming: the
-      # source's file), then #prune_dropped_hooks' (incoming: none). A stray
-      # file in hooks/ is in neither: the upgrade leaves it.
-      def trash_bound_hooks(provenance, bundle, manifest, source_dir)
-        src = ->(file) { File.join(source_dir, "hooks", file) }
-        listed = manifest.hooks.keys.select { |file| file.is_a?(String) && !file.empty? }
-        listed = Dir.glob(src.call("*.rb")).map { |file| File.basename(file) } if manifest.hooks.empty?
-        shipped = listed.reject do |file|
-          (File.symlink?(src.call(file)) || File.exist?(src.call(file))) && AssetInstaller.linked?(src.call(file), source_dir)
-        end
-        incoming = shipped.select { |file| File.exist?(src.call(file)) }.to_h { |file| [file, src.call(file)] }
-        incoming.merge!((bundle.hooks.keys - shipped).to_h { |file| [file, nil] })
-        incoming.filter_map do |file, from|
-          "hooks/#{file}" if Trash.edit?(File.join(provenance.hooks_dir, file), recorded: bundle.hooks[file]&.sha256, incoming: from)
-        end
+        assets = AssetState.in(provenance.guardrails_dir, kind_of_file: :rule, recorded: bundle.guardrails,
+                                                          incoming: rules.to_h { |file| [File.basename(file), file] }) +
+                 AssetState.in(provenance.plugin_dir, kind_of_file: :plugin, recorded: bundle.plugin_shas, incoming: plugin) +
+                 AssetState.in(provenance.scripts_dir, kind_of_file: :script, recorded: bundle.scripts, incoming: scripts)
+        Trash.edits(provenance.hooks_dir, "hooks", bundle.hooks.transform_values(&:sha256)) +
+          assets.select(&:edited?).map(&:label)
       end
 
-      # Installed hooks, rules and the plugin whose sha differs from the
-      # recorded one (they didn't load), as hooks/F, guardrails/F, plugin/F.
+      # Installed rules and the plugin whose sha differs from the recorded
+      # one (they didn't load), as guardrails/F, plugin/F.
       def edited_executables(name, bundle)
         provenance = Provenance.new(name: name)
         edited = []
-        bundle.hooks.each do |file, hook|
-          edited << "hooks/#{file}" if edited?(File.join(provenance.hooks_dir, file), hook.sha256)
-        end
         bundle.guardrails.each do |file, sha|
           edited << "guardrails/#{file}" if edited?(File.join(provenance.guardrails_dir, file), sha)
         end

data/lib/samagotchi/memory_bundle/status.rb

@@ -3,6 +3,7 @@
 require_relative "file_digest"
 require_relative "provenance"
 require_relative "file_state"
+require_relative "asset_state"
 require_relative "manifest"
 require_relative "../version"
 require_relative "index_updater"
@@ -16,14 +17,17 @@ module Samagotchi
       # A bundle as this chi reads it now (what chi bundle status prints):
       # its stored record, the scope it resolves to (scope_error when it
       # can't), the folder its files belong in, what each file looks like on
-      # disk, its installed plugin, why none of its hooks load, and its needs
+      # disk, its installed plugin, the class-file hooks its record still
+      # has (retired_hooks: they don't load), and its needs
       # with what this process's PATH found. The +files+ entries and +plugin+
       # stay Hashes: their fields differ per case (an unchecked file has no
       # paths at all). An entry's behind is its FileStanding::Behind, nil for a
       # file that isn't; merge_note its FileStanding::MergeNote, nil without one;
       # unreadable: the file is there, but this chi can't read it.
+      # rules and scripts: each recorded one by name, "ok", "modified" or
+      # "missing" (asset_states).
       Report = Data.define(:provenance, :scope, :scope_error, :target_dir, :files, :plugin,
-                           :hooks_requires_failure, :needs)
+                           :rules, :scripts, :retired_hooks, :needs)
 
       # A scope this chi can't resolve (a newer chi's, a hand edit) isn't
       # guessed: scope_error says so, target_dir is nil and each file is
@@ -69,7 +73,9 @@ module Samagotchi
         end
         Report.new(provenance: bundle, scope: scope, scope_error: target_dir ? nil : "unknown scope: #{scope}",
                    target_dir: target_dir, files: details, plugin: plugin_status(provenance, bundle),
-                   hooks_requires_failure: hooks_requires_failure(bundle), needs: needs_status(bundle))
+                   rules: asset_states(provenance.guardrails_dir, :rule, bundle.guardrails),
+                   scripts: asset_states(provenance.scripts_dir, :script, bundle.scripts),
+                   retired_hooks: retired_hooks(provenance, bundle), needs: needs_status(bundle))
       end
 
       # A FileState digest as the Report has it: nil for none, or one that
@@ -77,13 +83,28 @@ module Samagotchi
       def self.digest_or_nil(digest) = digest == :unreadable ? nil : digest
       private_class_method :digest_or_nil
 
-      # Why none of the bundle's hooks load (this chi doesn't meet its
-      # requires_chi, Hooks::BundleLoader), or nil: it has no hooks or meets it.
-      def self.hooks_requires_failure(bundle)
-        manifest = bundle.manifest
-        return nil if manifest.hooks.empty?
+      # The class-file hooks the record still has (a 0.157 install's; chi
+      # loads none, Manifest::HooksRetired), each "ok" or "missing" in
+      # hooks/, by name; {} for none.
+      # @return [Hash{String => String}]
+      def self.retired_hooks(provenance, bundle)
+        bundle.hooks.keys.sort.to_h do |file|
+          [file, File.exist?(File.join(provenance.hooks_dir, file)) ? "ok" : "missing"]
+        end
+      end
 
-        manifest.requires_chi_failure
+      # Each recorded rule or script: "missing" (not there), "modified" (its
+      # AssetState is edited: the next install replaces it, a copy kept in
+      # the trash; an edited rule doesn't load) or "ok"; {} for none.
+      # @return [Hash{String => String}]
+      def self.asset_states(dir, kind_of_file, recorded)
+        recorded.keys.sort.to_h do |name|
+          asset = AssetState.of(File.join(dir, name), kind_of_file: kind_of_file, recorded: recorded[name], name: name)
+          [name, if asset.state == :missing then "missing"
+                 elsif asset.edited? then "modified"
+                 else "ok"
+                 end]
+        end
       end
 
       # The stored needs, each with found: from this process's PATH (the