samagotchi 0.16.0 → 0.18.0

data/lib/samagotchi/guardrails/targets.rb

@@ -4,20 +4,27 @@ require_relative "../tools/tool_path"
 require_relative "../tools/memory"
 require_relative "../log"
 require_relative "model_size"
-require_relative "../memory_bundle/index_sync"
+require_relative "outside"
+require_relative "shell_git_dirs"
 
 module Samagotchi
   module Guardrails
     # What a tool call acts on, resolved the way the tools resolve it: the
     # shell command, absolute paths (against Dir.pwd, as the file tools have
     # no cwd:), the directory a command runs in, its repo root, and whether
-    # a path leaves the repo (the cwd when there is no repo).
+    # a path leaves the session's repo (Outside: the context cwd's repo
+    # root, the cwd when there is no repo; not the call's own cwd:).
     class Targets
       SHELL_TOOLS = %w[execute task_create].freeze
       PATH_TOOLS = %w[write edit read memory_write].freeze
 
       attr_reader :tool, :command, :paths, :cwd, :repo_root
 
+      # @return [String] the session's repo root (the context cwd's; the cwd
+      #   outside a repo): what outside_repo measures from. repo_root is the
+      #   call's (its own cwd: for shell and plugin tools).
+      attr_reader :session_root
+
       # @return [String, nil] the effective model: its bare name (no host
       #   prefix) and its key (ModelOverlay.key_for), for a rule's models:
       attr_reader :model_name, :model_key
@@ -62,7 +69,7 @@ module Samagotchi
           args = call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
         end
         new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd), args: args,
-            model_name: model_name, model_key: model_key)
+            model_name: model_name, model_key: model_key, session_root: context.repo_root(base) || base)
       end
 
       # What a plugin tool's targets: callable says the call acts on:
@@ -102,7 +109,9 @@ module Samagotchi
         nil
       end
 
-      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil, model_name: nil, model_key: nil)
+      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil, model_name: nil, model_key: nil,
+                     session_root: nil)
+        @session_root = session_root || repo_root || cwd
         @args = args
         @model_name = model_name
         @model_key = model_key
@@ -123,20 +132,28 @@ module Samagotchi
         @small_model = ModelSize.small?(@model_name, @model_key)
       end
 
-      # Whether any path is outside the repo root (the cwd outside a repo).
-      # A memory's file doesn't count (MemoryBundle::IndexSync.memory_scope):
-      # write/edit there is what memory_write does, unasked; index.md, the
-      # bundles dir and the rest of chi's config dir still count.
+      # Whether any path is outside the session's repo (Outside.outside?:
+      # symlinks resolved; a memory's file and tmp dirs don't count).
       def outside_repo?
-        root = @repo_root || @cwd
-        @paths.any? do |p|
-          p != root && !p.start_with?(File.join(root, "")) && !MemoryBundle::IndexSync.memory_scope(p)
-        end
+        @paths.any? { |p| Outside.outside?(p, root: @session_root) }
+      end
+
+      # Where a shell call runs mutating git (ShellGitDirs: dirs, and
+      # :unknown for one the text doesn't tell); [] for other tools.
+      def git_dirs
+        @git_dirs ||= shell? ? ShellGitDirs.for(@command, cwd: @cwd) : []
+      end
+
+      # Whether a shell call runs mutating git outside the session's repo
+      # (an :unknown dir doesn't count).
+      def git_outside_repo?
+        git_dirs.any? { |dir| dir.is_a?(String) && Outside.outside?(dir, root: @session_root) }
       end
 
       # The hook event's targets: hash.
       def to_h
-        { command: @command, paths: @paths, cwd: @cwd, repo_root: @repo_root, outside_repo: outside_repo? }
+        { command: @command, paths: @paths, cwd: @cwd, repo_root: @repo_root, outside_repo: outside_repo?,
+          git_dirs: git_dirs.map(&:to_s) }
       end
     end
   end

data/lib/samagotchi/guardrails.rb

@@ -2,6 +2,8 @@
 
 require_relative "guardrails/verdict"
 require_relative "guardrails/context"
+require_relative "guardrails/outside"
+require_relative "guardrails/shell_git_dirs"
 require_relative "guardrails/targets"
 require_relative "guardrails/model_size"
 require_relative "guardrails/approval"

data/lib/samagotchi/iteration_limit.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "log"
+
+module Samagotchi
+  # A turn's iteration limit (how many model ↔ tool rounds before the turn
+  # stops and offers to continue), one resolver for the Engine, the worker
+  # and the REPL.
+  module IterationLimit
+    KEY = "turn.max_iterations"
+    # A turn's limit unless turn.max_iterations says otherwise, and the
+    # loops' own default.
+    DEFAULT = 100
+    # A --no-interrupt / --non-interactive turn's, at least: nobody is there
+    # to answer a continue offer.
+    NO_INTERRUPT = 1000
+
+    # @param no_interrupt [Boolean] the turn runs with nobody to answer: the
+    #   larger of NO_INTERRUPT and the configured limit, so a configured one
+    #   above 1000 is never lowered
+    # @return [Integer]
+    def self.for(no_interrupt: false) = no_interrupt ? [NO_INTERRUPT, configured].max : configured
+
+    # turn.max_iterations (env SAMAGOTCHI_TURN_MAX_ITERATIONS); one below 1
+    # is DEFAULT, with a warning.
+    # @return [Integer]
+    def self.configured
+      value = Config.get(KEY)
+      return DEFAULT if value.nil?
+      return value if value.is_a?(Integer) && value >= 1
+
+      Log.warn(:config, "invalid_value", echo: "Warning: #{KEY} must be 1 or more, got #{value.inspect} — using #{DEFAULT}",
+                                         key: KEY)
+      DEFAULT
+    end
+  end
+end

data/lib/samagotchi/kernel_loop.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "iteration_limit"
 require_relative "model_profile"
 require_relative "tool_call_parser"
 require_relative "config"
@@ -174,7 +175,7 @@ module Samagotchi
     #   at the conversation tail (prefix KV cache preserved) and a
     #   :pending_input_merged stream event is emitted.
     # @return [LLM::ModelResult] final visible response with continuation metadata
-    def run(messages, max_iterations: 100, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+    def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
       @turn_settings = @turn_settings.with(model_name: completion_model_name(model_name))
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
                                   pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars))

data/lib/samagotchi/llm/backend.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require_relative "model_result"
 
 module Samagotchi
@@ -14,7 +15,7 @@ module Samagotchi
     #
     # The raw-prompt KernelLoop is NativeBackend; the chat loop is ChatLoop.
     class ModelBackend
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         raise NotImplementedError, "#{self.class}#complete must be implemented"
       end

data/lib/samagotchi/llm/chat_loop.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require "json"
 require_relative "backend"
 require_relative "model_result"
@@ -56,7 +57,7 @@ module Samagotchi
 
       def provider = :chat
 
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         raise ArgumentError, "ChatLoop has no adapter" unless @adapter
 

data/lib/samagotchi/llm/native_backend.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require_relative "backend"
 require_relative "model_result"
 
@@ -15,7 +16,7 @@ module Samagotchi
 
       def provider = :native
 
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         @kernel.run(
           messages,

data/lib/samagotchi/memory_bundle/builder.rb

@@ -67,6 +67,8 @@ module Samagotchi
             raise BuildError, "Requested file(s) not found in #{@scope} scope: #{missing.join(', ')}"
           end
           candidates = allow.map { |k| candidates_by_basename[k] }
+        else
+          candidates = leave_out_owned(candidates, resolved_name)
         end
 
         # Compute checksums and detect placeholders
@@ -250,6 +252,26 @@ module Samagotchi
 
       private
 
+      # Without an allowlist, a memory another installed bundle owns (its
+      # record lists it) isn't the user's to share: left out, one line
+      # each. The bundle being built (same name) keeps its own.
+      def leave_out_owned(candidates, name)
+        require_relative "provenance"
+        owners = candidates.to_h do |path|
+          [path, Provenance.claimants(File.basename(path), scope: @scope, except: name)]
+        end
+        left_out = owners.reject { |_, names| names.empty? }
+        left_out.each do |path, names|
+          @warnings << "Left out #{File.basename(path)}: installed by bundle #{names.join(", ")} (name it to include it)"
+        end
+        kept = candidates - left_out.keys
+        if kept.empty?
+          raise BuildError, "No memories to build in #{@scope} scope: every one belongs to an installed bundle " \
+                            "(#{left_out.keys.map { |p| File.basename(p) }.join(", ")}); name the ones to include"
+        end
+        kept
+      end
+
       def normalize_scope(val)
         return nil if val.nil? || val.to_s.strip.empty?
         v = val.to_s.strip.downcase

data/lib/samagotchi/memory_bundle/index_updater.rb

@@ -10,18 +10,22 @@ module Samagotchi
     module IndexUpdater
       MEMORY_INDEX = "index"
       LOCK_FILE = ".index.lock"
-      def self.update_index(scope, entry_name, byte_count, description = nil)
+      # @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)
         return true unless index_path
         locked_write(File.dirname(index_path)) do |content|
-          new_line = managed_line(entry_name, scope, byte_count, description)
+          new_line = managed_line(entry_name, scope, byte_count, description, source || nil)
           next auto_index_header + "\n\n" + new_line + "\n" if content.nil? || content.strip.empty?
 
           pattern = managed_pattern(entry_name)
           if content.match?(pattern)
-            existing_desc = extract_description(content[pattern].to_s)
-            resolved_desc = description&.to_s&.strip || existing_desc
-            new_line = managed_line(entry_name, scope, byte_count, resolved_desc)
+            existing = content[pattern].to_s.chomp
+            resolved_desc = description&.to_s&.strip || extract_description(existing)
+            resolved_source = source.nil? ? extract_source(existing) : (source || nil)
+            new_line = managed_line(entry_name, scope, byte_count, resolved_desc, resolved_source)
             next content.sub(pattern) { new_line + $1 }
           end
           content.end_with?("\n") ? "#{content}#{new_line}\n" : "#{content}\n#{new_line}\n"
@@ -57,8 +61,9 @@ module Samagotchi
           Samagotchi::AtomicFile.write(index_path, updated) unless updated.nil?
         end
       end
-      def self.managed_line(name, scope, byte_count, description)
+      def self.managed_line(name, scope, byte_count, description, source = nil)
         line = "- **#{name}** · #{scope} · #{date_str} · #{byte_count}"
+        line += " · from #{source}" unless source.to_s.strip.empty?
         desc = description&.to_s&.strip
         line += " — #{desc}" unless desc.to_s.empty?
         line
@@ -70,6 +75,12 @@ module Samagotchi
           $1
         end
       end
+      # The bundle a managed line names ("· from <bundle>", before any
+      # " — description"), or nil.
+      def self.extract_source(line)
+        line.to_s.chomp.split(" — ", 2).first[/ · from (\S+)/, 1]
+      end
+
       def self.auto_index_header
         "# Memory Index\n\n" \
           "Managed entries below are auto-maintained by memory_write " \

data/lib/samagotchi/memory_bundle/installer.rb

@@ -9,6 +9,7 @@ require_relative "source"
 require_relative "placeholder"
 require_relative "index_updater"
 require_relative "merger"
+require_relative "trash"
 require_relative "../version"
 require_relative "../bundle_needs"
 
@@ -41,8 +42,13 @@ module Samagotchi
         @warnings = []
         @placeholder_warnings = []
         @conflicts = {}
+        @trash = Trash.new(name)
       end
 
+      # Where an upgrade moved the files the bundle no longer ships (nil:
+      # none moved).
+      def trash_dir = @trash.dir
+
       def run
         normalized_dir = nil
         source_owned = false
@@ -73,14 +79,24 @@ module Samagotchi
         existing_provenance = provenance.read
         # A plain install over an installed bundle: summary points at upgrade.
         @reinstall = existing_provenance && !@upgrade && !@force && !@dry_run
+        # The bundle owns (records, upgrades, removes) only the files it
+        # wrote: these, from an earlier install, and the ones written now.
+        # A same-name file that was already there is the user's: skipped
+        # and never recorded.
+        owned_before = existing_provenance && existing_provenance[:files].is_a?(Hash) ? existing_provenance[:files].keys.map(&:to_s) : []
+        owned = []
 
         Dir.glob(File.join(normalized_dir, "*.md")).each do |file_path|
           file_key = File.basename(file_path)
           all_files_in_bundle << file_key
           target_path = File.join(target_dir, file_key)
 
-          if @upgrade && existing_provenance && !@force && !@dry_run
+          if @upgrade && existing_provenance && !@force && File.exist?(target_path) && !owned_before.include?(file_key)
+            # Not the bundle's (the user's, or another bundle's): no merge.
+            skip_existing(file_key, file_path, target_path, target_scope)
+          elsif @upgrade && existing_provenance && !@force && !@dry_run
             # 3-way merge path for upgrades
+            owned << file_key
             base_path = provenance.base_path(file_key)
             classification = Merger.classify(base_path: base_path, current_path: target_path, incoming_path: file_path)
             case classification
@@ -120,16 +136,13 @@ module Samagotchi
             else
               @results[file_key] = { status: "would_install" }
             end
-          elsif File.exist?(target_path) && !@force && FileUtils.identical?(file_path, target_path)
-            @results[file_key] = { status: "skipped", reason: "already up to date" }
-            update_target_index(target_scope, target_path, file_key)
           elsif File.exist?(target_path) && !@force
-            @results[file_key] = { status: "skipped", reason: "already exists" }
-            @warnings << "Skipped #{file_key} (already exists; use --force to overwrite)"
-            # Still update the index for skipped files.
-            update_target_index(target_scope, target_path, file_key)
+            # A re-install keeps what an earlier install wrote.
+            owned << file_key if owned_before.include?(file_key)
+            skip_existing(file_key, file_path, target_path, target_scope, owned: owned_before.include?(file_key))
           else
             FileUtils.cp(file_path, target_path) unless @dry_run
+            owned << file_key
             @results[file_key] = { status: "installed" }
             # Update index for newly installed files.
             update_target_index(target_scope, target_path, file_key) unless @dry_run
@@ -302,7 +315,7 @@ module Samagotchi
         if manifest && !@dry_run
           provenance_files = {}
           if @upgrade && existing_provenance
-            all_files_in_bundle.each do |file_key|
+            owned.each do |file_key|
               target_path = File.join(target_dir, file_key)
               next unless File.exist?(target_path)
               status = @results[file_key] ? @results[file_key][:status].to_s : nil
@@ -338,7 +351,7 @@ module Samagotchi
               end
             end
           else
-            all_files_in_bundle.each do |file_key|
+            owned.each do |file_key|
               target_path = File.join(target_dir, file_key)
               next unless File.exist?(target_path)
 
@@ -408,7 +421,7 @@ module Samagotchi
         lines << "Updated: #{updated.join(', ')}" unless updated.empty?
         lines << "Would install: #{would_install.join(', ')}" unless would_install.empty?
         lines << "Fast-forward: #{fast_forward.join(', ')}" unless fast_forward.empty?
-        lines << "Removed (no longer in the bundle): #{removed.join(', ')}" unless removed.empty?
+        lines << "Removed (no longer in the bundle): #{removed.join(', ')}#{trash_dir ? " (moved to #{trash_dir})" : ""}" unless removed.empty?
         lines << "Would remove (no longer in the bundle): #{would_remove.join(', ')}" unless would_remove.empty?
         lines << "Kept (local edits preserved): #{kept.join(', ')}" unless kept.empty?
         lines << "Skipped: #{skipped.join(', ')}" unless skipped.empty?
@@ -422,9 +435,27 @@ module Samagotchi
 
       private
 
+      # A file already in the target dir that the install doesn't write: the
+      # same bytes are "already up to date", others are skipped with a
+      # --force hint (a dry run: would_skip). Its index line is refreshed
+      # (not on a dry run).
+      def skip_existing(file_key, file_path, target_path, scope, owned: false)
+        if FileUtils.identical?(file_path, target_path)
+          @results[file_key] = { status: "skipped", reason: "already up to date" }
+        elsif @dry_run
+          @results[file_key] = { status: "would_skip" }
+          return
+        else
+          @results[file_key] = { status: "skipped", reason: "already exists" }
+          @warnings << "Skipped #{file_key} (already exists; use --force to overwrite)"
+        end
+        update_target_index(scope, target_path, file_key, owned: owned) unless @dry_run
+      end
+
       # A file the previous version installed that this one doesn't ship is
-      # removed (with its index line) when it still matches what was
-      # installed, or with --force; one the user edited is kept with a note.
+      # moved to the trash (with its index line removed) when it still
+      # matches what was installed, or with --force; one the user edited is
+      # kept with a note.
       def prune_dropped_files(previous_files, bundle_files, target_dir, scope, provenance)
         previous_files.each do |old_key, meta|
           key = old_key.to_s
@@ -432,10 +463,14 @@ module Samagotchi
           target = File.join(target_dir, key)
           next unless File.exist?(target)
 
-          if @force || installed_unchanged?(target, meta, provenance.base_path(key))
+          others = Provenance.claimants(key, scope: scope, except: @name)
+          if others.any?
+            @results[key] = { status: "kept_shared", reason: "bundle #{others.join(", ")} has it too" }
+            @warnings << "Kept #{key}: no longer in the bundle, but bundle #{others.join(", ")} has it too"
+          elsif @force || installed_unchanged?(target, meta, provenance.base_path(key))
             @results[key] = { status: @dry_run ? "would_remove" : "removed", reason: "no longer in the bundle" }
             next if @dry_run
-            FileUtils.rm_f(target)
+            @trash.move(target)
             remove_target_index(scope, key)
           else
             @results[key] = { status: "kept_pruned", reason: "local edits preserved" }
@@ -452,11 +487,12 @@ module Samagotchi
         File.exist?(base_path) && Provenance.file_sha(target) == Provenance.file_sha(base_path)
       end
 
+      # Not fatal, like update_target_index: a warning says so.
       def remove_target_index(scope, file_key)
         IndexUpdater.remove_index(scope, file_key.delete_suffix(".md"))
         IndexUpdater.remove_index(scope, file_key) # legacy "name.md" line
-      rescue StandardError
-        # Best-effort, like update_target_index.
+      rescue StandardError => e
+        @warnings << "index.md: line for #{file_key.delete_suffix(".md")} not removed (#{e.message})"
       end
 
       # One warning per need not found on this PATH (read-only, so dry-run
@@ -514,16 +550,19 @@ module Samagotchi
         dest
       end
 
-      def update_target_index(scope, file_path, file_key)
+      # +owned+: the bundle wrote (owns) the file, so its line says
+      # "· from <bundle>"; a skipped file's line keeps whatever it had.
+      def update_target_index(scope, file_path, file_key, owned: true)
         byte_count = File.exist?(file_path) ? File.size(file_path) : 0
         entry_name = file_key.delete_suffix(".md")
         begin
           # Index lines use the entry name (as memory_write does); drop the
           # legacy "name.md" line older installs wrote.
           IndexUpdater.remove_index(scope, file_key) unless entry_name == file_key
-          IndexUpdater.update_index(scope, entry_name, byte_count)
-        rescue => _e
-          # Silently skip index updates — they're best-effort.
+          IndexUpdater.update_index(scope, entry_name, byte_count, source: owned ? @name : nil)
+        rescue StandardError => e
+          # Not fatal (the file is in place): a warning says so.
+          @warnings << "index.md: line for #{entry_name} not updated (#{e.message})"
         end
       end
 

data/lib/samagotchi/memory_bundle/profile.rb

@@ -30,8 +30,10 @@ module Samagotchi
         def failed? = !failed.empty?
       end
       # removed: members uninstalled; blocked: name => why; gone: the meta
-      # itself was removed (only once every member is).
-      UninstallResult = Struct.new(:name, :removed, :blocked, :gone, keyword_init: true)
+      # itself was removed (only once every member is); trash: member =>
+      # [memory files, the trash dir they were moved to]; warnings: the
+      # members' ("member: line").
+      UninstallResult = Struct.new(:name, :removed, :blocked, :gone, :trash, :warnings, keyword_init: true)
 
       module_function
 
@@ -127,10 +129,13 @@ module Samagotchi
         shipped = File.join(shipped_dir, name)
         manifest = File.file?(File.join(shipped, "manifest.yml")) ? Manifest.read(dir: shipped) : nil
         members = recorded(data, manifest)
-        result = UninstallResult.new(name: name, removed: [], blocked: {}, gone: false)
+        result = UninstallResult.new(name: name, removed: [], blocked: {}, gone: false, trash: {}, warnings: [])
         (members & installed_names).each do |member|
-          Uninstaller.new(name: member, force: force).run
+          uninstaller = Uninstaller.new(name: member, force: force)
+          uninstaller.run
           result.removed << member
+          result.trash[member] = [uninstaller.trashed_files, uninstaller.trash_dir] if uninstaller.trash_dir
+          result.warnings.concat(uninstaller.warnings.map { |w| "#{member}: #{w}" })
         rescue Uninstaller::UninstallError => e
           result.blocked[member] = e.message
         end

data/lib/samagotchi/memory_bundle/provenance.rb

@@ -84,6 +84,20 @@ module Samagotchi
         end
       end
 
+      # The other installed bundles of +scope+ whose record lists the memory
+      # file +file_key+, by name (a manifest that doesn't read is left out).
+      # A project-scoped record doesn't say which project: one from another
+      # repo counts too, which errs on keeping the file.
+      def self.claimants(file_key, scope:, except: nil, dir: bundles_dir)
+        each_installed(dir: dir).filter_map do |name, data|
+          next if name == except || data[:error]
+          next unless (data[:scope].to_s.empty? ? "system" : data[:scope].to_s) == scope.to_s
+          next unless data[:files].is_a?(Hash) && data[:files].keys.map(&:to_s).include?(file_key.to_s)
+
+          name
+        end
+      end
+
       # The hex digest a manifest records, in either of its formats:
       # "sha256:<hex>" (hooks, rules, the plugin) or bare <hex> (a memory
       # file's checksum:). "" when none is recorded.

data/lib/samagotchi/memory_bundle/shipped_update.rb

@@ -143,13 +143,15 @@ module Samagotchi
         row
       end
 
-      # The .md files whose local edits conflict with the shipped version.
+      # The bundle's .md files whose local edits conflict with the shipped
+      # version (a same-name file it didn't install is skipped, not merged).
       def conflicts(row, data)
         provenance = Provenance.new(name: row.name)
         target_dir = Status.resolve_target_dir(row.scope)
-        return [] unless data[:files]
+        return [] unless data[:files].is_a?(Hash)
 
-        Dir.glob(File.join(row.source_dir, "*.md")).map { |f| File.basename(f) }.sort.select do |key|
+        owned = data[:files].keys.map(&:to_s)
+        (Dir.glob(File.join(row.source_dir, "*.md")).map { |f| File.basename(f) }.sort & owned).select do |key|
           Merger.classify(base_path: provenance.base_path(key), current_path: File.join(target_dir, key),
                           incoming_path: File.join(row.source_dir, key)) == :conflict
         end

data/lib/samagotchi/memory_bundle/system_bundle.rb

@@ -169,11 +169,13 @@ module Samagotchi
         result(:restored, from: version, to: version)
       end
 
-      # The files an upgrade would keep: edited here and changed in the
-      # shipped bundle (a dry run's kept).
+      # The files an upgrade would keep: installed by the bundle, edited
+      # here and changed in the shipped bundle (a dry run's kept).
       def conflicting(gem_manifest)
         provenance = Provenance.new(name: BUNDLE_NAME)
-        gem_manifest.files.keys.map(&:to_s).sort.select do |key|
+        owned = (provenance.read || {})[:files]
+        owned = owned.is_a?(Hash) ? owned.keys.map(&:to_s) : []
+        (gem_manifest.files.keys.map(&:to_s).sort & owned).select do |key|
           Merger.classify(base_path: provenance.base_path(key), current_path: File.join(MemoryPaths.system_dir, key),
                           incoming_path: File.join(GEM_BUNDLE_DIR, key)) == :conflict
         end