samagotchi 0.158.0 → 0.159.0

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "asset_state"
+require_relative "file_actions"
 require_relative "file_digest"
 require_relative "manifest"
 require_relative "provenance"
@@ -20,8 +22,11 @@ module Samagotchi
     # 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_edits); a link never is.
+    # Each folder is one loop over its files' AssetStates (#install_set):
+    # FileActions' asset tables say what each gets, the dry run reading the
+    # same row. An edited file it replaces or removes is copied to the trash
+    # first, under its subfolder (AssetState#edited?, Trash.edit?'s rule); a
+    # link never is.
     class AssetInstaller
       # What was installed: the paths Provenance#write records (each
       # empty / nil on a dry run).
@@ -32,6 +37,10 @@ module Samagotchi
       # The retire's summary words (Installer#summary): why the hooks went.
       RETIRED = "chi no longer loads class-file bundle hooks"
 
+      # A dry run's word for a real run's (Installer#summary): nothing would
+      # be written to a file already up to date.
+      DRY_WORDS = { installed: :would_install, updated: :would_update, up_to_date: :up_to_date }.freeze
+
       # @param source_dir [String] the normalized bundle source
       # @param manifest [Manifest, nil] nil for a non-strict install without one
       # @param existing [InstalledBundle, nil] the record before this install
@@ -65,9 +74,9 @@ module Samagotchi
       def run
         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
+        guardrail_files = install_set(:rule, rules_incoming(incoming_rules))
+        plugin_file = install_set(:plugin, plugin_incoming).values.first
+        script_files = install_set(:script, scripts_incoming)
         # 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
@@ -95,8 +104,8 @@ module Samagotchi
       # 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
+      # :would_remove) 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
@@ -104,7 +113,7 @@ module Samagotchi
 
         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
+          @results["hooks/#{file}"] = @dry_run ? retired.with(word: :would_remove) : retired
         end
         return if @dry_run
 
@@ -114,44 +123,15 @@ module Samagotchi
 
       def retired = Installer::FileResult.new(word: :removed, note: RETIRED)
 
-      # The bundle's guardrails/*.yml into <bundle_dir>/guardrails/: the
-      # set replaces what an earlier version installed. Same bytes as
-      # installed are reported up to date, not "Installed".
-      # @return [Hash{String => String}] basename => installed path ({} on a dry run)
-      def install_guardrails(incoming_rules)
-        target = @provenance.guardrails_dir
-        results = incoming_rules.to_h { |src| [src, result_for(src, File.join(target, File.basename(src)), updated: false)] }
-        if @dry_run
-          results.each { |src, result| @results["guardrails/#{File.basename(src)}"] = planned(result) }
-          return {}
-        end
-
-        @trash.copy_edits(target, "guardrails", @existing&.guardrails, incoming_rules.to_h { |src| [File.basename(src), src] })
-        FileUtils.rm_rf(target)
-        return {} if incoming_rules.empty?
+      # The bundle's guardrails/*.yml, by basename.
+      def rules_incoming(incoming_rules) = incoming_rules.to_h { |src| [File.basename(src), src] }
 
-        FileUtils.mkdir_p(target)
-        incoming_rules.to_h do |src|
-          dest = File.join(target, File.basename(src))
-          place(src, dest)
-          @results["guardrails/#{File.basename(src)}"] = results[src]
-          [File.basename(src), dest]
-        end
-      end
-
-      # Copy the manifest's plugin file into the bundle's plugin/ dir,
-      # warning when its sha256 differs from the declared one or this chi
-      # doesn't meet requires_chi (the Engine then won't load it).
-      # @return [String, nil] the installed file (nil: none, or a dry run)
-      def install_plugin
+      # The manifest's plugin file, warning when this chi doesn't meet
+      # requires_chi (the Engine then won't load it). {} without one.
+      # @return [Hash{String => String}] its file => the source file
+      def plugin_incoming
         plugin = @manifest&.plugin
-        unless plugin
-          unless @dry_run
-            @trash.copy_edits(@provenance.plugin_dir, "plugin", @existing&.plugin_shas)
-            FileUtils.rm_rf(@provenance.plugin_dir)
-          end
-          return nil
-        end
+        return {} unless plugin
 
         src = File.join(@bundle_dir, plugin[:file])
         raise Installer::InstallError, "the manifest names plugin #{plugin[:file]}, which the bundle doesn't have" unless File.file?(src)
@@ -160,83 +140,84 @@ module Samagotchi
         if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, @chi_version))
           @warnings << "Plugin #{plugin[:file]} won't load: #{failure}"
         end
-        dest = File.join(@provenance.plugin_dir, plugin[:file])
-        result = result_for(src, dest, updated: @upgrade && @provenance.installed?)
-        if @dry_run
-          @results[plugin[:file]] = planned(result)
-          return nil
-        end
-
-        @trash.copy_edits(@provenance.plugin_dir, "plugin", @existing&.plugin_shas, { plugin[:file] => src })
-        FileUtils.rm_rf(@provenance.plugin_dir)
-        FileUtils.mkdir_p(@provenance.plugin_dir)
-        place(src, dest)
-        @results[plugin[:file]] = result
-        warning = FileDigest.mismatch("plugin #{plugin[:file]}", dest, @manifest.checksum_for_plugin) if @strict && !@dev
-        @warnings << warning if warning
-        dest
+        { plugin[:file] => src }
       end
 
-      # The manifest's scripts, copied into <bundle_dir>/scripts/ (the
-      # folder replaced: a script the new version dropped goes). A declared
-      # sha256 that differs warns, as a plugin's does.
-      # @return [Hash{String => String}] file name => installed path
-      def install_scripts
+      # The manifest's scripts (a dev install warns of one it can't run).
+      # @return [Hash{String => String}] file name => the source file
+      def scripts_incoming
         scripts = @manifest&.scripts || {}
-        scripts.each_key do |file|
+        scripts.keys.to_h do |file|
           src = File.join(@bundle_dir, "scripts", file)
           raise Installer::InstallError, "the manifest names scripts/#{file}, which the bundle doesn't have" unless File.file?(src)
           raise Installer::InstallError, "scripts/#{file} is a symlink (not installed)" if linked?(src)
 
           @warnings << "scripts/#{file} is not executable; chmod +x #{src}" if @dev && !File.executable?(src) && !page_only?(file)
+          [file, src]
         end
-        results = scripts.keys.to_h do |file|
-          [file, result_for(File.join(@bundle_dir, "scripts", file), File.join(@provenance.scripts_dir, file),
-                            updated: @upgrade && @provenance.installed?)]
+      end
+
+      # One folder of the bundle's own dir (guardrails/, plugin/, scripts/),
+      # replaced whole by +incoming+: each file's AssetState and its action
+      # (FileActions' ASSET_INSTALL, or ASSET_UPGRADE over an installed
+      # bundle), one result per incoming file (a dry run's DRY_WORDS of it,
+      # and nothing written), an edit copied to the trash first (save_first),
+      # then the folder replaced. A file the source dropped goes without a
+      # word. A plugin or script whose sha256 differs from the declared one
+      # warns (not a dev link: it is the source).
+      # @param incoming [Hash{String => String}] name => the source file, in
+      #   the order the results list them
+      # @return [Hash{String => String}] name => installed path ({} on a dry run)
+      def install_set(kind_of_file, incoming)
+        dir, recorded = folder(kind_of_file)
+        command = @upgrade && @provenance.installed? ? :upgrade : :install
+        states = AssetState.in(dir, kind_of_file: kind_of_file, recorded: recorded, incoming: incoming)
+                           .to_h { |asset| [asset.name, [asset, FileActions.for_asset(command, asset)]] }
+        results = incoming.keys.to_h do |name|
+          asset, action = states.fetch(name)
+          [name, Installer::FileResult.new(word: @dry_run ? DRY_WORDS.fetch(action.word) : action.word, state: asset, action: action)]
         end
         if @dry_run
-          results.each { |file, result| @results["scripts/#{file}"] = planned(result) }
+          results.each { |name, result| @results[result_key(kind_of_file, name)] = result }
           return {}
         end
 
-        @trash.copy_edits(@provenance.scripts_dir, "scripts", @existing&.scripts,
-                          scripts.keys.to_h { |file| [file, File.join(@bundle_dir, "scripts", file)] })
-        FileUtils.rm_rf(@provenance.scripts_dir)
-        return {} if scripts.empty?
-
-        FileUtils.mkdir_p(@provenance.scripts_dir)
-        scripts.to_h do |file, declared|
-          dest = File.join(@provenance.scripts_dir, file)
-          place(File.join(@bundle_dir, "scripts", file), dest)
-          @results["scripts/#{file}"] = results[file]
-          FileUtils.chmod(0o755, dest) unless @dev
-          warning = FileDigest.mismatch("script #{file}", dest, declared.to_s.delete_prefix("sha256:")) if @strict && !@dev
-          @warnings << warning if warning
-          [file, dest]
+        states.each_value { |asset, action| @trash.copy(asset.path, as: asset.label) if action.save_first }
+        FileUtils.rm_rf(dir)
+        return {} if incoming.empty?
+
+        FileUtils.mkdir_p(dir)
+        incoming.to_h do |name, src|
+          dest = File.join(dir, name)
+          place(src, dest)
+          @results[result_key(kind_of_file, name)] = results[name]
+          FileUtils.chmod(0o755, dest) if kind_of_file == :script && !@dev
+          if (declared = declared_sha(kind_of_file, name)) && results[name].action.do == :write_incoming && @strict && !@dev
+            warning = FileDigest.mismatch("#{kind_of_file} #{name}", dest, declared)
+            @warnings << warning if warning
+          end
+          [name, dest]
         end
       end
 
-      # What the real run reports for +src+ over +dest+: up to date when the
-      # bytes are the same, else updated (+updated+: an upgrade over an
-      # install, of a file that is there) or installed. A dry run records #planned of it, so the two
-      # can't drift.
-      def result_for(src, dest, updated:)
-        word = if File.file?(dest) && FileUtils.identical?(src, dest) then :up_to_date
-               elsif updated && File.exist?(dest) then :updated
-               else :installed
-               end
-        Installer::FileResult.new(word: word)
+      # The kind's folder and the record's shas for it.
+      def folder(kind_of_file)
+        case kind_of_file
+        when :rule then [@provenance.guardrails_dir, @existing&.guardrails]
+        when :plugin then [@provenance.plugin_dir, @existing&.plugin_shas]
+        else [@provenance.scripts_dir, @existing&.scripts]
+        end
       end
 
-      # A dry run's word for a result: would_install, would_update,
-      # would_remove, or the up to date result as it is (nothing would be
-      # written).
-      def planned(result)
-        case result.word
-        when :installed then result.with(word: :would_install)
-        when :updated then result.with(word: :would_update)
-        when :removed then result.with(word: :would_remove)
-        else result
+      # Its key in the Installer's results (the summary's name): a rule's
+      # guardrails/r.yml, the plugin's own file name, a script's scripts/s.sh.
+      def result_key(kind_of_file, name) = kind_of_file == :plugin ? name : "#{AssetState::FOLDERS.fetch(kind_of_file)}/#{name}"
+
+      # The manifest's sha256 for a plugin or script (hex), nil for a rule.
+      def declared_sha(kind_of_file, name)
+        case kind_of_file
+        when :plugin then @manifest.checksum_for_plugin
+        when :script then @manifest.scripts[name].to_s.delete_prefix("sha256:")
         end
       end
 
@@ -267,7 +248,7 @@ module Samagotchi
       # 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 install_plugin does.
+      # until chi is updated): say so at install, as #plugin_incoming does.
       def warn_rules_requires_chi(rule_files)
         return if @manifest.nil? || rule_files.empty?
 

data/lib/samagotchi/memory_bundle/asset_state.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "trash"
+
+module Samagotchi
+  module MemoryBundle
+    # One file of a bundle's own folder (a guardrail rule, the plugin, a
+    # script) as a command finds it: derived from the file on disk, the sha
+    # the record holds and the source file that would take its place, never
+    # stored. FileActions' ASSET_* tables say what each command does in each
+    # state; AssetInstaller, ShippedUpdate's plan, Uninstaller and Status read
+    # it. Whether it is edited is Trash.edit?'s answer (what the trash keeps a
+    # copy of), asked once in .of.
+    #
+    #   name          its path in its folder (r.yml, plugin.rb, s.sh)
+    #   path          where it is installed
+    #   kind_of_file  :rule, :plugin or :script
+    #   state         :new        not there (or a broken link), the source has it
+    #                 :unchanged  the source's bytes already (a dev link to them too)
+    #                 :pristine   the recorded sha, the source has other bytes
+    #                 :edited     neither the recorded sha (none recorded: unknown,
+    #                             so edited) nor the source's bytes
+    #                 :linked     a link (a dev install's) to other bytes than the
+    #                             source's: it points at a source nothing here touches
+    #                 :dropped_pristine, :dropped_edited  there, the source hasn't
+    #                             it (with no source read, as uninstall and status
+    #                             do, every file there is one of these)
+    #                 :missing    recorded, not there, the source hasn't it
+    #   recorded      the record's sha256 for it (nil: not in the record)
+    #   incoming      the source file that replaces it (nil: none)
+    AssetState = Data.define(:name, :path, :kind_of_file, :state, :recorded, :incoming) do
+      # @param path [String] the installed file
+      # @param recorded [String, nil] its recorded sha256
+      # @param incoming [String, nil] the source file put in its place
+      def self.of(path, kind_of_file:, recorded: nil, incoming: nil, name: File.basename(path))
+        new(name: name, path: path, kind_of_file: kind_of_file, state: state_of(path, recorded, incoming),
+            recorded: recorded, incoming: incoming)
+      end
+
+      # Every file of the folder +dir+ a command meets: each file in it (at
+      # any depth, as Trash#copy_edits reads it; a linked dir isn't followed),
+      # each incoming one and each recorded one, by name.
+      # @param recorded [Hash, nil] name => recorded sha256
+      # @param incoming [Hash] name => the source file
+      # @return [Array<AssetState>]
+      def self.in(dir, kind_of_file:, recorded: nil, incoming: {})
+        recorded ||= {}
+        on_disk = if File.symlink?(dir) || !File.directory?(dir) then []
+                  else Dir.glob("**/*", File::FNM_DOTMATCH, base: dir).reject { |file| File.directory?(File.join(dir, file)) }
+                  end
+        (on_disk | incoming.keys | recorded.keys).sort.map do |name|
+          of(File.join(dir, name), kind_of_file: kind_of_file, recorded: recorded[name], incoming: incoming[name], name: name)
+        end
+      end
+
+      def self.state_of(path, recorded, incoming)
+        if incoming && File.file?(path) && FileUtils.identical?(incoming, path) then :unchanged
+        elsif File.symlink?(path) && File.exist?(path) then :linked
+        elsif !File.file?(path) then incoming ? :new : :missing
+        elsif Trash.edit?(path, recorded: recorded, incoming: incoming) then incoming ? :edited : :dropped_edited
+        else incoming ? :pristine : :dropped_pristine
+        end
+      end
+      private_class_method :state_of
+
+      # Trash.edit?'s rule (asked in .of): an edit a replace or a removal
+      # would lose, so the trash keeps a copy first.
+      def edited? = %i[edited dropped_edited].include?(state)
+
+      # Where the trash keeps its copy, and the plan names it: guardrails/r.yml,
+      # plugin/plugin.rb, scripts/s.sh.
+      def label = "#{self.class::FOLDERS.fetch(kind_of_file)}/#{name}"
+    end
+
+    class AssetState
+      # Each kind's folder in the bundle's own dir (and in the trash).
+      FOLDERS = { rule: "guardrails", plugin: "plugin", script: "scripts" }.freeze
+    end
+  end
+end

data/lib/samagotchi/memory_bundle/file_actions.rb

@@ -22,6 +22,8 @@ module Samagotchi
       #   :keep            left as it is (already the bundle's, or kept)
       #   :skip            left as it is, the bundle doesn't take it
       #   :move_to_trash   moved to the trash (a removal)
+      #   :remove          deleted (an asset: save_first copies an edit to the
+      #                    trash first)
       #   :refuse          the command stops
       #   :restore         the bundle's text put back (SystemBundle at its version)
       # save_first: a copy of the old bytes goes to the trash before a write
@@ -157,6 +159,55 @@ module Samagotchi
 
       TABLES = { install: INSTALL, force: FORCE, upgrade: UPGRADE, remerge: REMERGE, restore: RESTORE,
                  uninstall: UNINSTALL }.freeze
+
+      # A bundle's own folder (rules, the plugin, scripts: AssetState), which
+      # every install replaces whole: the source's files go in, the rest go,
+      # an edit (AssetState#edited?) copied to the trash first. A cell is keyed
+      # [state, kind_of_file] or [state, :any]. A file the source has is
+      # written even when it has its bytes already (and so checked against the
+      # manifest's sha, as any other).
+      ASSET_WRITE = Action.new(do: :write_incoming, word: :installed, next_base: :on_disk)
+      ASSET_REMOVE = Action.new(do: :remove, word: nil, next_base: :none, record: :drop)
+      ASSET_GONE = Action.new(do: :skip, word: nil, next_base: :none, record: :drop)
+
+      # A plain install, install --force, and an upgrade with no record yet.
+      ASSET_INSTALL = {
+        %i[new any] => ASSET_WRITE, %i[unchanged any] => ASSET_WRITE.with(word: :up_to_date),
+        %i[pristine any] => ASSET_WRITE, %i[edited any] => ASSET_WRITE.with(save_first: true),
+        %i[linked any] => ASSET_WRITE,
+        # The source dropped it: it goes with the folder, without a word.
+        %i[dropped_pristine any] => ASSET_REMOVE, %i[dropped_edited any] => ASSET_REMOVE.with(save_first: true),
+        %i[missing any] => ASSET_GONE
+      }.freeze
+
+      # An upgrade (--force too) over the record: a file it replaces is
+      # updated, except a rule (an upgrade lists a replaced rule as installed:
+      # the corpus's rule-installed).
+      ASSET_UPGRADE = ASSET_INSTALL.merge(
+        %i[pristine any] => ASSET_WRITE.with(word: :updated),
+        %i[edited any] => ASSET_WRITE.with(word: :updated, save_first: true),
+        %i[linked any] => ASSET_WRITE.with(word: :updated),
+        %i[pristine rule] => ASSET_WRITE, %i[edited rule] => ASSET_WRITE.with(save_first: true),
+        %i[linked rule] => ASSET_WRITE
+      ).freeze
+
+      # Uninstall: the folder goes (no source, so every file there is a
+      # dropped_* or a link), an edit copied to the trash first, --force or not.
+      ASSET_UNINSTALL = {
+        %i[dropped_pristine any] => ASSET_REMOVE, %i[dropped_edited any] => ASSET_REMOVE.with(save_first: true),
+        %i[linked any] => ASSET_REMOVE, %i[missing any] => ASSET_GONE
+      }.freeze
+
+      ASSET_TABLES = { install: ASSET_INSTALL, upgrade: ASSET_UPGRADE, uninstall: ASSET_UNINSTALL }.freeze
+
+      # The command's action for an AssetState: [state, kind_of_file], then
+      # [state, :any].
+      # @param command [Symbol] an ASSET_TABLES key
+      # @return [Action, nil] nil: the command never meets the state
+      def self.for_asset(command, asset)
+        table = ASSET_TABLES.fetch(command)
+        table[[asset.state, asset.kind_of_file]] || table[[asset.state, :any]]
+      end
       # The kinds whose row depends on another bundle listing the file.
       SHARED_ASKED = %i[dropped_pristine dropped_edited pristine pristine_no_base edited edited_no_base].freeze
 

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"
@@ -28,10 +29,11 @@ module Samagotchi
     #
     # .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). Rules,
-    # the plugin and scripts are replaced, an older chi's hooks removed; 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 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
@@ -293,21 +295,24 @@ module Samagotchi
       end
 
       # What the upgrade from +source_dir+ copies to the trash, as
-      # hooks/F, guardrails/F, plugin/F, scripts/F: Trash.edits over the
-      # folders AssetInstaller replaces or removes, each file against the one
-      # it puts in its place. Rules, the plugin and scripts: their whole
-      # folder, which the upgrade replaces. hooks/: an older chi's, which the
-      # upgrade removes whole (AssetInstaller#retire_hooks; no incoming).
+      # 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)] }
+        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)) +
-          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)
+          assets.select(&:edited?).map(&:label)
       end
 
       # Installed rules and the plugin whose sha differs from the recorded

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"
@@ -23,8 +24,10 @@ module Samagotchi
       # 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,
-                           :retired_hooks, :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
@@ -70,6 +73,8 @@ 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),
+                   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
 
@@ -88,6 +93,20 @@ module Samagotchi
         end
       end
 
+      # 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
       # shell's; a worker's PATH can differ, see docs/memory.md). A needs:
       # that doesn't parse is none.

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "digest"
 require_relative "../memory_paths"
 require_relative "provenance"
+require_relative "asset_state"
 require_relative "file_actions"
 require_relative "index_updater"
 require_relative "trash"
@@ -144,12 +145,17 @@ module Samagotchi
       private
 
       # Copies each edited file of the bundle's own folder to the trash: the
-      # rm_rf below takes them, --force or not.
+      # rm_rf below takes them, --force or not. Rules, the plugin and
+      # scripts by their source-less AssetState and ASSET_UNINSTALL's
+      # save_first; an older chi's hooks/ by Trash#copy_edits.
       def save_edits(provenance, bundle)
         @trash.copy_edits(provenance.hooks_dir, "hooks", bundle.hooks.transform_values(&:sha256))
-        @trash.copy_edits(provenance.guardrails_dir, "guardrails", bundle.guardrails)
-        @trash.copy_edits(provenance.plugin_dir, "plugin", bundle.plugin_shas)
-        @trash.copy_edits(provenance.scripts_dir, "scripts", bundle.scripts)
+        { rule: [provenance.guardrails_dir, bundle.guardrails], plugin: [provenance.plugin_dir, bundle.plugin_shas],
+          script: [provenance.scripts_dir, bundle.scripts] }.each do |kind_of_file, (dir, recorded)|
+          AssetState.in(dir, kind_of_file: kind_of_file, recorded: recorded).each do |asset|
+            @trash.copy(asset.path, as: asset.label) if FileActions.for_asset(:uninstall, asset)&.save_first
+          end
+        end
       end
 
       # A kept shared file's index line names the bundle that still has it

data/lib/samagotchi/run_options.rb

@@ -214,6 +214,7 @@ module Samagotchi
                  chi models [--format json] [TEXT]   the models --model takes, from every host
                  chi home [set [--ruby PATH] | doctor]   the Ruby every chi launch boots
                  chi project [init [DIR]]         this folder's project; init makes a folder in no git repository one
+                 chi schedule <add|list|show|tick|run-now|enable|disable|cancel>   durable schedules that outlive every worker
                  chi remote <add|ls|rm>           other machines' chi web, for chi --remote NAME
                  chi --remote NAME <send|answer|note|context|sessions|share|review> …   those commands on that machine (or CHI_REMOTE=NAME)
                  chi --remote NAME --attach ID | --resume ID | --dir DIR [-p TEXT]   a session on that machine, in this terminal