samagotchi 0.159.0 → 0.161.0

data/lib/samagotchi/guardrails/approvals.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "digest"
 require "json"
 require "fileutils"
 require "time"
@@ -13,7 +14,9 @@ module Samagotchi
     # written aside and renamed under an exclusive flock (several chi
     # processes share it). An entry relaxes an ask, never a deny:
     #   session — this exact call (tool + normalized command / paths) in
-    #             this session;
+    #             this session; a command's in its place too (the
+    #             worktree or folder it ran in, and a digest of its env:),
+    #             since the same text acts on whatever they point at;
     #   repo    — this exact call in this repo (the cwd outside a repo);
     #   rule    — anything this rule (from this source) asks about here.
     # "This repo" is the repository (repo: its common git dir), so an
@@ -74,11 +77,14 @@ module Samagotchi
         here = ->(e) { e["repo"] ? e["repo"] == repo : e["repo_root"] == place }
         session_id = verdict.context&.session_id
         session_only = SESSION_ONLY_RULES.include?(verdict.rule.to_s)
+        command_place = session_place(verdict)
         list.find do |e|
           next false if session_only && e["scope"] != "session"
 
           case e["scope"]
-          when "session" then session_id && e["session_id"] == session_id && e["key"] == key
+          when "session"
+            session_id && e["session_id"] == session_id && e["key"] == key &&
+              (command_place.nil? || e.slice("repo_root", "env") == command_place)
           when "repo" then here.call(e) && e["key"] == key
           when "rule"
             # One rule's grant can't answer for a second rule's ask on the call.
@@ -94,7 +100,9 @@ module Samagotchi
         entry = { "scope" => scope, "tool" => verdict.targets&.tool || verdict.call[:name].to_s,
                   "acts_as" => verdict.targets&.acts_as, "rule" => verdict.rule, "source" => verdict.source, "created_at" => Time.now.utc.iso8601 }
         case scope
-        when "session" then entry.merge!("session_id" => verdict.context&.session_id, "key" => key_for(verdict))
+        when "session"
+          entry.merge!("session_id" => verdict.context&.session_id, "key" => key_for(verdict))
+          entry.merge!(session_place(verdict) || {})
         when "repo"
           entry.merge!("repo_root" => place_for(verdict), "repo" => verdict.targets&.repo, "key" => key_for(verdict))
         when "rule" then entry.merge!("repo_root" => place_for(verdict), "repo" => verdict.targets&.repo)
@@ -131,6 +139,22 @@ module Samagotchi
         t&.repo_root || t&.cwd || verdict.context&.cwd
       end
 
+      # Where a session entry of a command holds: the call's worktree root
+      # (or folder: #place_for; never the common git dir, which every
+      # worktree shares) and, when it sets one, a sha256 of its env: (never
+      # the env: it may hold a secret). nil for a call with no command:
+      # its paths are its place. An entry without them (stored before) no
+      # longer matches: one more ask.
+      # @return [Hash, nil]
+      def self.session_place(verdict)
+        t = verdict.targets
+        return nil unless t&.command
+
+        env = t.env.to_h
+        digest = env.empty? ? nil : Digest::SHA256.hexdigest(JSON.generate(env.map { |k, v| [k.to_s, v.to_s] }.sort))
+        { "repo_root" => place_for(verdict), "env" => digest }.compact
+      end
+
       private
 
       # @param locked [Boolean] the caller holds the store's lock

data/lib/samagotchi/guardrails/child_boundary.rb

@@ -17,14 +17,20 @@ module Samagotchi
     # (a repo or rule answer would hold in every worktree, for every child),
     # when:
     #   write, edit: a path is outside root (Outside: tmp dirs and memory
-    #     files never are);
+    #     files never are); so is a path a plugin tool's targets: declare
+    #     the call writes (writes: true), the same declaration
+    #     ProtectedPaths reads — a call is judged by what its targets say it
+    #     acts on, not by its tool's name;
     #   execute, task_create: mutating git runs in a dir outside root
     #     (ShellGitDirs), or a command that isn't read-only starts outside
     #     root (its cwd:, else Dir.pwd) or names a path in the repository's
     #     other checkouts (the main one and sibling worktrees) or its
     #     common git dir; or it runs git that changes what all checkouts
     #     share, from anywhere (SharedGit: config, update-ref, worktree add,
-    #     stash clear, tags, another branch's delete).
+    #     stash clear, tags, another branch's delete). A plugin tool's
+    #     declared command: is checked for what chi can read for sure only:
+    #     SharedGit, and whether the call's cwd: is outside root (its text
+    #     may not be shell; Targets#rule_command).
     # Paths elsewhere in a command (/usr/bin, ~/.gem) don't count, and
     # read-only commands never ask, nor do ones that only write into a tmp
     # dir (> / >>, cp's destination, tee; Targets#read_only_but_tmp_writes?). Paths resolve under chi's env and the
@@ -67,12 +73,39 @@ module Samagotchi
 
       def crosses?(targets, root)
         case targets.tool
-        when "write", "edit" then targets.paths.any? { |path| Outside.outside?(path, root: root) }
+        when "write", "edit" then paths_cross?(targets, root)
         when *SHELL_TOOLS then shell_crosses?(targets, root)
-        else false
+        else
+          # chi's other own tools (read, memory_write, …) are unchanged:
+          # memory_write carries writes: for ProtectedPaths, but its paths
+          # are memory files (Outside exempts them) and its `..` entry names
+          # asked for nothing here before.
+          return false if Targets::CORE_TOOLS.include?(targets.tool)
+
+          plugin_crosses?(targets, root)
         end
       end
 
+      def paths_cross?(targets, root)
+        targets.paths.any? { |path| Outside.outside?(path, root: root) }
+      end
+
+      # A plugin tool, by what its targets: say it acts on (Targets#writes?,
+      # #command, #cwd), not by its name: paths its targets say it writes
+      # like a write's, and a declared command like a shell's — but for the
+      # command only what chi can read for sure: git that changes what every
+      # checkout shares (SharedGit), and where the call runs (its cwd:). A
+      # plugin's command text may not be shell (Targets#rule_command), so
+      # the shell half's git-dir, cd and redirect reads are left out; a
+      # plugin that wants more can bring a rule of its own.
+      def plugin_crosses?(targets, root)
+        return true if targets.writes? && paths_cross?(targets, root)
+        return :shared if targets.command && SharedGit.changes?(targets.command, own_branch: @branch.call)
+        return true if targets.command && targets.cwd && Outside.outside?(targets.cwd, root: root)
+
+        false
+      end
+
       def shell_crosses?(targets, root)
         return true if targets.git_dirs.any? { |dir| dir.is_a?(String) && Outside.outside?(dir, root: root) }
         return :shared if SharedGit.changes?(targets.command, own_branch: @branch.call)

data/lib/samagotchi/guardrails/protected_paths.rb

@@ -4,7 +4,8 @@ require_relative "path_resolve"
 
 module Samagotchi
   module Guardrails
-    # Core checks on what the file tools (write, edit, memory_write) touch,
+    # Core checks on what a call writes (Targets#writes?: write, edit,
+    # memory_write, and a plugin tool whose targets: say writes: true),
     # after the hooks and before the rules. Paths are compared with
     # symlinks resolved (on the longest existing parent, `..` taken
     # physically, a dangling symlink followed: PathResolve.reals, the
@@ -14,7 +15,8 @@ module Samagotchi
     #         hooks, rules, manifests), attached context (a source's
     #         command runs later, outside the gate; chi context writes
     #         it) and System 1's saved runs (a label there may train a
-    #         model); nothing legitimate writes there through the file tools.
+    #         model); nothing legitimate writes there through a tool
+    #         that says it writes.
     #   ask (once / session): config.yml, home.json (the chi home: the
     #         Ruby every chi launch boots), the chi shim (ChiShim: the
     #         `chi` every tool runs) and the plain hooks dir. The
@@ -24,7 +26,6 @@ module Samagotchi
     # execute can still write all of them (the guardrails bundle adds a
     # text match for that).
     class ProtectedPaths
-      FILE_TOOLS = %w[write edit memory_write].freeze
       SOURCE = "core"
 
       # @param store_dir [String] <state dir>/guardrails
@@ -50,10 +51,12 @@ module Samagotchi
         ].select { |_, root, _| root }
       end
 
-      # Vote on +verdict+ (its targets).
+      # Vote on +verdict+ (its targets): a call whose targets say it writes
+      # (Targets#writes?: write, edit, memory_write, or a plugin tool's
+      # targets: writes: true) is judged on its paths.
       def check(verdict)
         targets = verdict.targets
-        return verdict unless targets && FILE_TOOLS.include?(targets.tool)
+        return verdict unless targets&.writes?
 
         paths = targets.paths.flat_map { |p| PathResolve.reals(p) }
         @deny.each do |rule, root, reason|

data/lib/samagotchi/guardrails/targets.rb

@@ -90,6 +90,15 @@ module Samagotchi
       #   reads it)
       attr_reader :label
 
+      # @return [Boolean] whether the call writes the paths its targets name:
+      #   chi's own write, edit and memory_write, and a plugin tool whose
+      #   targets: say writes: true (a literal true only). The checks that
+      #   guard a write (ProtectedPaths, ChildBoundary) ask this rather than
+      #   the tool's name, so a plugin tool that acts like one is judged
+      #   like one.
+      attr_reader :writes
+      alias writes? writes
+
       # @return [Boolean] a memory_write call that removes a memory (remove:
       #   true), for a rule's memory: remove
       attr_reader :memory_remove
@@ -126,6 +135,7 @@ module Samagotchi
         args = nil
         acts_as = nil
         label = nil
+        writes = false
         env = {}
         case tool
         when *SHELL_TOOLS
@@ -134,14 +144,17 @@ module Samagotchi
           given = call[:cwd].to_s.strip
           cwd = File.expand_path(given, base) unless given.empty?
         when "write", "edit"
+          writes = true
           paths.concat(absolutes(call[:path], base))
         when "read"
           paths.concat(absolutes(call[:content], base))
         when "memory_write"
+          writes = true
           paths << memory_path(call, model_key)
         else
           given = plugin_targets(call, registry, surface)
           command = given[:command]
+          writes = given[:writes]
           given_cwd = given[:cwd].to_s.strip
           cwd = File.expand_path(given_cwd, base) unless given_cwd.empty?
           paths.concat(given[:paths].flat_map { |path| absolutes(path, cwd) })
@@ -154,25 +167,29 @@ module Samagotchi
         memory_overlay = tool == "memory_write" && !memory_remove && call[:current_model_only].to_s.strip.downcase == "true"
         memory = tool == "memory_write" ? memory_facts(call) : nil
         new(tool: tool, command: command, paths: paths.compact, cwd: cwd, env: env, repo_root: context.repo_root(cwd),
-            repo: context.repo(cwd), args: args, acts_as: acts_as, label: label, memory_remove: memory_remove,
+            repo: context.repo(cwd), args: args, acts_as: acts_as, label: label, writes: writes,
+            memory_remove: memory_remove,
             memory_overlay: memory_overlay, memory: memory,
             model_name: model_name, model_key: model_key, session_root: context.repo_root(base) || base,
             chi_dirs: -> { chi_dirs(context, base) })
       end
 
       # What a plugin tool's targets: callable says the call acts on:
-      # {command:, paths:, cwd:, acts_as:, args:, label:}, each optional; a callable
+      # {command:, paths:, writes:, cwd:, acts_as:, args:, label:}, each
+      # optional; a callable
       # that raises or gives something else counts as nothing (and is
       # logged). args: counts when it is a Hash; acts_as: is dropped (and
       # logged) when it names a core tool or another bundle's tool, so a
       # call can't pass for one and match (or reuse the approvals of) its
-      # rules. label: counts when it is one short line (.label_of). A
+      # rules. label: counts when it is one short line (.label_of). writes:
+      # counts only for a literal true: the tool says its paths are written,
+      # and the checks that guard write/edit judge them (.writes?). A
       # missing surface (Tools::MissingSurface) is raised, never taken as
       # nothing: call_tool's acts_as would go missing, and with it the
       # mcp_* rules on the call (fail-open).
       def self.plugin_targets(call, registry, surface = nil)
         entry = entry_of(call[:name], registry, surface)
-        none = { command: nil, paths: [], cwd: nil, acts_as: nil, args: nil, label: nil }
+        none = { command: nil, paths: [], writes: false, cwd: nil, acts_as: nil, args: nil, label: nil }
         return none unless entry && !entry.core? && entry.targets
 
         given = entry.targets_of(call, surface)
@@ -180,7 +197,8 @@ module Samagotchi
 
         given = given.transform_keys(&:to_sym)
         command = given[:command].to_s
-        { command: command.empty? ? nil : command, paths: Array(given[:paths]).map(&:to_s), cwd: given[:cwd],
+        { command: command.empty? ? nil : command, paths: Array(given[:paths]).map(&:to_s), writes: given[:writes] == true,
+          cwd: given[:cwd],
           acts_as: acts_as_of(given[:acts_as], entry, registry, surface), args: given[:args].is_a?(Hash) ? given[:args] : nil,
           label: label_of(given[:label], entry) }
       rescue Tools::MissingSurface
@@ -318,10 +336,11 @@ module Samagotchi
       # @param env [Hash{String=>String}] the call's env: (.env_of)
       def initialize(tool:, command:, paths:, cwd:, repo_root:, env: {}, repo: nil, args: nil, acts_as: nil,
                      label: nil, model_name: nil, model_key: nil, session_root: nil, chi_dirs: nil,
-                     memory_remove: false, memory_overlay: false, memory: nil)
+                     memory_remove: false, memory_overlay: false, memory: nil, writes: false)
         @env = env
         @acts_as = acts_as
         @label = label
+        @writes = writes
         @memory_remove = memory_remove
         @memory_overlay = memory_overlay
         @memory = memory

data/lib/samagotchi/hook_routes.rb

@@ -24,7 +24,6 @@ module Samagotchi
     # (a chi.on handler :log, or :deny for an on_error: :fail_closed one).
     HOOK_FAILURE_EFFECTS = {
       log: "it's skipped, and only the log has its next failures",
-      skip: "it's skipped, and its next failures are silent",
       deny: "it denies every tool call it guards, and its next failures are in each denial's reason"
     }.freeze
 

data/lib/samagotchi/live_versions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "rubygems/version"
 require_relative "config"
 require_relative "session"
 require_relative "version"
@@ -38,9 +39,13 @@ module Samagotchi
       end
     end
 
-    # The live workers on another version than +version+ (unknown counts).
+    # The live workers older than the target chi (unknown versions count).
+    # Compat's N-1 verdict is for hints; these callers are adopting the new code.
     def stale_workers(version = VERSION, state_dir: Session.default_state_dir)
-      workers(state_dir: state_dir).reject { |w| w.version == version }
+      target = Gem::Version.new(version)
+      workers(state_dir: state_dir).select do |worker|
+        worker.version.nil? || !Gem::Version.correct?(worker.version) || Gem::Version.new(worker.version) < target
+      end
     end
 
     # The /api/info of a chi web on host:port, or nil when nothing (or not

data/lib/samagotchi/memory_bundle/asset_installer.rb

@@ -50,7 +50,8 @@ module Samagotchi
       # @param chi_version [String] the chi this install is for (the Installer's;
       #   a caller that checks its own bundles against another version passes it)
       def initialize(name:, source_dir:, manifest:, provenance:, existing:, results:, warnings:, conflicts:, trash:,
-                     force: false, strict: true, upgrade: false, dry_run: false, dev: false, chi_version: Samagotchi::VERSION)
+                     force: false, strict: true, upgrade: false, dry_run: false, dev: false, chi_version: Samagotchi::VERSION,
+                     refuse_mismatch: false)
         @name = name
         @bundle_dir = source_dir
         @manifest = manifest
@@ -66,11 +67,42 @@ module Samagotchi
         @dry_run = dry_run
         @dev = dev
         @chi_version = chi_version
+        @refuse_mismatch = refuse_mismatch
+      end
+
+      # Raises for the first plugin or script the manifest names that the
+      # bundle doesn't have (or ships as a link), writing nothing: the
+      # Installer runs it before its first write.
+      # @raise [Installer::InstallError]
+      def check_named_files
+        plugin_source
+        scripts_sources
+      end
+
+      # The same early pass on the shas: the plugin and each script against the
+      # bundle's own bytes, before anything is written. Only when the caller
+      # refuses a mismatch (`chi bundle install/upgrade`; chi update, a profile
+      # and a dev install keep their warning), and not with --force, which
+      # installs a mismatch anyway.
+      # @raise [Installer::InstallError] one line per mismatched file
+      def check_named_checksums
+        return unless @refuse_mismatch && @strict && !@dev && !@force && @manifest
+
+        lines = []
+        if @manifest.plugin
+          lines << Installer.mismatch_refusal("plugin #{@manifest.plugin[:file]}", plugin_source,
+                                              @manifest.checksum_for_plugin, upgrade: @upgrade)
+        end
+        scripts_sources.each do |name, src|
+          lines << Installer.mismatch_refusal("script #{name}", src, declared_sha(:script, name), upgrade: @upgrade)
+        end
+        lines = lines.compact
+        raise Installer::InstallError, lines.join("\n") unless lines.empty?
       end
 
       # @return [Installed]
-      # @raise [Installer::InstallError] the manifest names a plugin or
-      #   script the bundle doesn't have
+      # @raise [Installer::InstallError] the same, when #check_named_files
+      #   wasn't run first
       def run
         incoming_rules = Dir.glob(File.join(@bundle_dir, "guardrails", "*.yml")).sort
                             .reject { |src| linked_out?(src, "guardrails/#{File.basename(src)}") }
@@ -115,7 +147,11 @@ module Samagotchi
         files.each do |file|
           @results["hooks/#{file}"] = @dry_run ? retired.with(word: :would_remove) : retired
         end
-        return if @dry_run
+        if @dry_run
+          edits = Trash.edits(dir, "hooks", @existing&.hooks&.transform_values(&:sha256))
+          @warnings << "Would copy to the trash first: #{edits.join(", ")}" unless edits.empty?
+          return
+        end
 
         @trash.copy_edits(dir, "hooks", @existing&.hooks&.transform_values(&:sha256))
         FileUtils.rm_rf(dir)
@@ -133,38 +169,53 @@ module Samagotchi
         plugin = @manifest&.plugin
         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)
-        raise Installer::InstallError, "plugin #{plugin[:file]} is a symlink (not installed)" if linked?(src)
-
+        src = plugin_source
         if (failure = Manifest.requires_chi_failure(@manifest.requires_chi, @chi_version))
           @warnings << "Plugin #{plugin[:file]} won't load: #{failure}"
         end
         { plugin[:file] => src }
       end
 
-      # The manifest's scripts (a dev install warns of one it can't run).
+      # The manifest's plugin file in the source, checked; nil without one.
+      def plugin_source
+        plugin = @manifest&.plugin
+        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)
+        raise Installer::InstallError, "plugin #{plugin[:file]} is a symlink (not installed)" if linked?(src)
+
+        src
+      end
+
+      # The manifest's scripts in the source, checked.
       # @return [Hash{String => String}] file name => the source file
-      def scripts_incoming
-        scripts = @manifest&.scripts || {}
-        scripts.keys.to_h do |file|
+      def scripts_sources
+        (@manifest&.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
       end
 
+      # 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_sources.each do |file, src|
+          @warnings << "scripts/#{file} is not executable; chmod +x #{src}" if @dev && !File.executable?(src) && !page_only?(file)
+        end
+      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).
+      #   then the folder replaced. A removed file is named in the summary.
+      #   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)
@@ -173,21 +224,36 @@ module Samagotchi
         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)]] }
+        if @dry_run
+          copies = states.filter_map { |_, (asset, action)| asset.label if action&.save_first }
+          @warnings << "Would copy to the trash first: #{copies.join(", ")}" unless copies.empty?
+        end
         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
+        dropped = states.filter_map do |name, (asset, action)|
+          next unless action&.do == :remove
+
+          [result_key(kind_of_file, name),
+           Installer::FileResult.new(word: @dry_run ? :would_remove : :removed, state: asset, action: action,
+                                     note: "no longer in the bundle")]
+        end
         if @dry_run
           results.each { |name, result| @results[result_key(kind_of_file, name)] = result }
+          dropped.each { |key, result| @results[key] = result }
           return {}
         end
 
         states.each_value { |asset, action| @trash.copy(asset.path, as: asset.label) if action.save_first }
         FileUtils.rm_rf(dir)
-        return {} if incoming.empty?
+        if incoming.empty?
+          dropped.each { |key, result| @results[key] = result }
+          return {}
+        end
 
         FileUtils.mkdir_p(dir)
-        incoming.to_h do |name, src|
+        installed = incoming.to_h do |name, src|
           dest = File.join(dir, name)
           place(src, dest)
           @results[result_key(kind_of_file, name)] = results[name]
@@ -198,6 +264,8 @@ module Samagotchi
           end
           [name, dest]
         end
+        dropped.each { |key, result| @results[key] = result }
+        installed
       end
 
       # The kind's folder and the record's shas for it.

data/lib/samagotchi/memory_bundle/bundle_hook.rb

@@ -2,38 +2,18 @@
 
 module Samagotchi
   module MemoryBundle
-    # One class-file hook's metadata, as an older chi's installed record
-    # (manifest.json) keeps it (chi no longer installs or loads them:
-    # Manifest::HooksRetired; it reads them to retire, uninstall and name
-    # them, and the trash selection takes #sha256): the file's sha256
-    # ("sha256:<hex>", "" when none is recorded), the events it registers
-    # for (manifest `event:` for one, `events:` a list; none: it isn't
-    # loaded), on_error (skip, log or fail_closed) and priority. The one
-    # place the defaults live.
-    class BundleHook < Data.define(:sha256, :events, :on_error, :priority)
-      DEFAULT_ON_ERROR = "skip"
-      DEFAULT_PRIORITY = 100
+    # One class-file hook's sha256 in an older chi's installed record; its
+    # other fields are ignored now that class-file hooks are retired.
+    BundleHook = Data.define(:sha256) do
+      def initialize(sha256: "") = super
 
-      # @param event [String, nil] one event (manifest `event:`)
-      # @param events [Array<String>, String, nil] the events (manifest
-      #   `events:`); `event:` and `events:` together are joined, blanks
-      #   and repeats dropped
-      def initialize(sha256: "", event: nil, events: nil, on_error: DEFAULT_ON_ERROR, priority: DEFAULT_PRIORITY)
-        names = [*event, *events].map { |e| e.to_s.strip }.reject(&:empty?).uniq.freeze
-        super(sha256: sha256, events: names, on_error: on_error, priority: priority)
-      end
-
-      # @param raw [Hash, BundleHook, nil] string keys (manifest.yml) or
-      #   symbol keys (a read record); missing or blank values get the
-      #   defaults
+      # @param raw [Hash, BundleHook, nil] string or symbol keys; legacy
+      #   metadata beyond sha256 is ignored
       def self.parse(raw)
         return raw if raw.is_a?(BundleHook)
 
         h = raw.is_a?(Hash) ? raw.transform_keys(&:to_s) : {}
-        on_error = h["on_error"].to_s.strip
-        new(sha256: prefixed(h["sha256"]), event: h["event"], events: h["events"],
-            on_error: on_error.empty? ? DEFAULT_ON_ERROR : on_error,
-            priority: (h["priority"] || DEFAULT_PRIORITY).to_i)
+        new(sha256: prefixed(h["sha256"]))
       end
 
       # "sha256:<hex>" from either form, "" for none.

data/lib/samagotchi/memory_bundle/file_actions.rb

@@ -180,14 +180,13 @@ module Samagotchi
         %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).
+      # An upgrade (--force too) over the record: a file it replaces is updated.
       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[pristine rule] => ASSET_WRITE.with(word: :updated),
+        %i[edited rule] => ASSET_WRITE.with(word: :updated, save_first: true),
         %i[linked rule] => ASSET_WRITE
       ).freeze
 

data/lib/samagotchi/memory_bundle/file_state.rb

@@ -11,6 +11,10 @@ module Samagotchi
     # the record's entry (R). Derived, never stored. FileActions says what each
     # acting command does in each state.
     #
+    # A file whose disk bytes are the text an interrupted run journaled
+    # (Provenance#write_pending) reads as the bundle's, at that run's
+    # version: owned (an entry made up if the record has none), its own base.
+    #
     # kind, with a source (install, upgrade, remerge, restore, plan):
     #   :new               not the bundle's, not on disk
     #   :user_same         not the bundle's, on disk with I's bytes
@@ -82,6 +86,7 @@ module Samagotchi
       # @return [FileState]
       def of(key, record:, provenance:, target_dir:, source_dir:, claimants: nil, shipped: true)
         entry = record&.files&.fetch(key, nil)
+        pending = provenance.pending_shas(key, target_dir: target_dir)
         paths = { base: provenance.base_path(key), current: File.join(target_dir, key),
                   incoming: source_dir && File.join(source_dir, key) }
         mark = mark_of(entry)
@@ -90,6 +95,12 @@ module Samagotchi
           incoming: source_dir && shipped ? digest(paths[:incoming]) : nil, recorded: entry && Provenance.recorded_sha(entry[:checksum]),
           marked_incoming: mark == :none ? nil : entry[:incoming_sha]
         )
+        if !pending.empty? && pending.include?(digests.disk)
+          # An interrupted run put this text here (Provenance#write_pending): it is the bundle's at
+          # that version, owned and its own base, not the user's file or an edit of the recorded one.
+          entry = (entry || {}).merge(checksum: digests.disk)
+          digests = digests.with(base: digests.disk, recorded: digests.disk)
+        end
         shared = nil
         lookup = -> { shared ||= claimants ? claimants.call(key) : [] }
         state = FileState.new(key: key, kind: nil, mark: mark, digests: digests, entry: entry, paths: paths, claimants: lookup)

data/lib/samagotchi/memory_bundle/index_updater.rb

@@ -14,8 +14,11 @@ module Samagotchi
       # @param source [String, false, nil] the bundle the memory came from
       #   ("· from <bundle>"): a name sets it, false drops it, nil keeps the
       #   line's (memory_write and write/edit pass nil)
-      def self.update_index(scope, entry_name, byte_count, description = nil, source: nil)
-        index_path = index_path_for(scope)
+      # @param target_dir [String, nil] the folder whose index.md to edit, when
+      #   it is not the one +scope+ resolves from the current folder (an
+      #   uninstall of a bundle journaled into another project)
+      def self.update_index(scope, entry_name, byte_count, description = nil, source: nil, target_dir: nil)
+        index_path = target_dir ? File.join(target_dir, "#{MEMORY_INDEX}.md") : index_path_for(scope)
         return true unless index_path
 
         locked_write(File.dirname(index_path)) do |content|
@@ -39,8 +42,8 @@ module Samagotchi
         /^- \*\*#{Regexp.escape(name)}\*\*[ \t]*(?:[·•].*|:.*)?(\r?\n|\z)/
       end
 
-      def self.remove_index(scope, entry_name)
-        index_path = index_path_for(scope)
+      def self.remove_index(scope, entry_name, target_dir: nil)
+        index_path = target_dir ? File.join(target_dir, "#{MEMORY_INDEX}.md") : index_path_for(scope)
         return true unless index_path && File.exist?(index_path)
 
         locked_write(File.dirname(index_path)) do |content|

data/lib/samagotchi/memory_bundle/installed_bundle.rb

@@ -26,7 +26,7 @@ module Samagotchi
     #               legacy_base: true on an older mark that has since got its incoming_sha (.legacy_mark?);
     #               why, missed, missed_places: FileStanding::Behind's, nil on an older mark;
     #               merged_version, merged_at, merged_trash: a merge no report has shown (Provenance#note_merged)
-    #   hooks       basename => BundleHook
+    #   hooks       basename => BundleHook (sha256; other legacy fields ignored)
     #   guardrails  basename => recorded sha256 ("" when none)
     #   scripts     file name => recorded sha256 ("" when none)
     #   plugin      PluginRef, nil without one