samagotchi 0.16.0 → 0.17.0

data/lib/samagotchi/engine.rb

@@ -243,7 +243,7 @@ module Samagotchi
       Log.debug(:model, "backend", provider: backend.provider) if Log.level?(:debug)
       @resume_session = session_id ? Session.load(session_id) : nil
       @prompt_builder = SystemPrompt.new(profile: -> { self.profile }, tools: -> { @tools }, session: -> { @session },
-                                         thinking: -> { turn_thinking }, memories: memories,
+                                         thinking: -> { turn_thinking }, model: -> { model_identity }, memories: memories,
                                          muted_memory_names: @muted_memory_names)
       @session = nil
       @session_observer = SessionObserver.new
@@ -411,6 +411,18 @@ module Samagotchi
       model_ref_for(@effective_model_name)
     end
 
+    # The effective model as the system prompt names it (SystemPrompt::ModelIdentity):
+    # the ref, its host, the overlay key and, for a local llama.cpp host
+    # only, the model its /props names when that differs. Never a new
+    # request: only the /props answer profile resolution already cached.
+    def model_identity
+      target = @host_registry.resolve(@effective_model_name)
+      entry = target.entry
+      host = entry && "host #{entry.name}, #{entry.url || "#{entry.host}:#{entry.port}"}"
+      SystemPrompt::ModelIdentity.new(ref: effective_model_ref, host: host, key: @model_key,
+                                      served: prompt_served_model(target), fallback_key: @fallback_model_key)
+    end
+
     # +name+'s resolved ref (ModelRef#ref).
     def model_ref_for(name)
       @host_registry.model_ref(name).ref
@@ -463,8 +475,8 @@ module Samagotchi
     def sync_model_key!
       @model_key = ModelOverlay.key_for(bare_model_name(@effective_model_name))
       typed_key = ModelOverlay.key_for(@host_registry.parse_qualified_model(@typed_model_name).last)
-      fallback = typed_key == @model_key ? nil : typed_key
-      @kernel.sync_model_key!(@model_key, fallback: fallback)
+      @fallback_model_key = typed_key == @model_key ? nil : typed_key
+      @kernel.sync_model_key!(@model_key, fallback: @fallback_model_key)
     end
     private :sync_model_key!
 
@@ -904,7 +916,7 @@ module Samagotchi
     # else [nil, nil].
     # @return [Array(String, String), Array(nil, nil)]
     def served_model(probe: true)
-      served_model_for(@metrics.snapshot, target: probe ? @host_registry.resolve(@effective_model_name) : nil)
+      served_model_for(@metrics.served_report, target: probe ? @host_registry.resolve(@effective_model_name) : nil)
     end
 
     # Read-only snapshot of the engine's view of the current session plus the
@@ -1307,6 +1319,7 @@ module Samagotchi
       def state_dir = engine.peer_state_dir
       def cancelled? = !!engine.active_cancel_controller&.cancelled?
       def relay = engine.relay_peer
+      def model_ref = engine.effective_model_ref
     end
 
     # What the approval relay needs from the parent's Engine (Peers#relay):
@@ -2125,7 +2138,8 @@ module Samagotchi
         ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:|
           ask_side_model(request, timeout: timeout, max_tokens: max_tokens, cancel_controller: cancel_controller)
         },
-        model_name: -> { @session&.model_name || @effective_model_name },
+        model_name: -> { effective_model_ref },
+        model_key: -> { @model_key },
         state_dir: -> { session_state_dir },
         scratch: -> { @scratch }
       )
@@ -2320,6 +2334,18 @@ module Samagotchi
       [nil, nil]
     end
 
+    # What a local native host's cached /props names, when it isn't the
+    # model asked for; nil for a chat or remote host, or before any probe.
+    def prompt_served_model(target)
+      entry = target.entry
+      return nil if entry.nil? || entry.chat? || entry.remote? || !target.client.respond_to?(:cached_server_props)
+
+      served = ServedModel.from_props(target.client.cached_server_props(model: target.bare_model))
+      served if ServedModel.differs?(target.bare_model, served)
+    rescue StandardError
+      nil
+    end
+
     # ── Prompt profile ─────────────────────────────────────────────────────────
 
     def resolve_profile

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

data/lib/samagotchi/memory_bundle/trash.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../memory_paths"
+
+module Samagotchi
+  module MemoryBundle
+    # Where a bundle operation puts the memory files it takes away
+    # (uninstall, an upgrade's dropped file): moved, never deleted, into
+    # <system memories>/.bundles/.trash/<bundle>-<YYYYmmdd-HHMMSS>/, one dir
+    # per operation (-2, -3… when one already has that name). A dot dir, so
+    # Provenance.each_installed never reads it as a bundle. Nothing prunes
+    # it: the user deletes it when sure.
+    class Trash
+      def self.root(bundles_dir: MemoryPaths.bundles_dir)
+        File.join(bundles_dir, ".trash")
+      end
+
+      # The dir, once a file was moved (nil before).
+      attr_reader :dir
+
+      def initialize(name, now: Time.now, bundles_dir: MemoryPaths.bundles_dir)
+        @name = name.to_s
+        @now = now
+        @bundles_dir = bundles_dir
+        @dir = nil
+      end
+
+      # Moves +path+ into the trash dir (created on the first call).
+      # @return [String] the file's new path
+      def move(path)
+        dest = File.join(ensure_dir, File.basename(path))
+        FileUtils.mv(path, dest)
+        dest
+      end
+
+      private
+
+      def ensure_dir
+        return @dir if @dir
+
+        base = File.join(self.class.root(bundles_dir: @bundles_dir), "#{@name}-#{@now.strftime("%Y%m%d-%H%M%S")}")
+        FileUtils.mkdir_p(File.dirname(base))
+        candidate = base
+        n = 1
+        loop do
+          Dir.mkdir(candidate)
+          break
+        rescue Errno::EEXIST
+          n += 1
+          candidate = "#{base}-#{n}"
+        end
+        @dir = candidate
+      end
+    end
+  end
+end

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -5,13 +5,17 @@ require_relative "../memory_paths"
 require_relative "provenance"
 require_relative "index_updater"
 require_relative "merger"
+require_relative "trash"
 
 module Samagotchi
   module MemoryBundle
     class Uninstaller
       class UninstallError < StandardError; end
 
-      attr_reader :warnings, :removed_files
+      # removed_files: the bundle's own hooks/ and plugin/ files (deleted);
+      # trashed_files: its memory files, moved to trash_dir (Trash), nil
+      # when none was moved.
+      attr_reader :warnings, :removed_files, :trashed_files
 
       def initialize(name:, scope: nil, force: false)
         @name = name
@@ -19,8 +23,12 @@ module Samagotchi
         @force = force
         @warnings = []
         @removed_files = []
+        @trashed_files = []
+        @trash = Trash.new(name)
       end
 
+      def trash_dir = @trash.dir
+
       def run
         provenance = Provenance.new(name: @name)
         data = provenance.read
@@ -40,12 +48,18 @@ module Samagotchi
           return true
         end
 
+        # A file another installed bundle lists too stays, edited or not.
+        shared = files.keys.map(&:to_s).to_h do |key|
+          [key, Provenance.claimants(key, scope: target_scope, except: @name)]
+        end.reject { |_, others| others.empty? }
+
         blocked = []
         files.each do |file_key, meta|
           file_key_str = file_key.to_s
           target_path = File.join(target_dir, file_key_str)
           base_path = provenance.base_path(file_key_str)
           next unless File.exist?(target_path)
+          next if shared.key?(file_key_str)
           if !@force && File.exist?(base_path) && Merger.current_modified?(base_path, target_path)
             blocked << file_key_str
             @warnings << "Skipped #{file_key_str}: local edits detected (use --force to remove)"
@@ -57,15 +71,23 @@ module Samagotchi
         files.each do |file_key, _meta|
           file_key_str = file_key.to_s
           target_path = File.join(target_dir, file_key_str)
+          if (others = shared[file_key_str])
+            next unless File.exist?(target_path)
+
+            @warnings << "Kept #{file_key_str}: bundle #{others.join(", ")} has it too"
+            retag(target_scope, target_path, file_key_str, others.first)
+            next
+          end
           if File.exist?(target_path)
-            FileUtils.rm_f(target_path)
-            @removed_files << file_key_str
+            @trash.move(target_path)
+            @trashed_files << file_key_str
           end
-          # Remove index line
+          # Remove index line (not fatal: a warning says so)
           begin
             IndexUpdater.remove_index(target_scope, file_key_str.delete_suffix(".md"))
             IndexUpdater.remove_index(target_scope, file_key_str) # legacy "name.md" line
-          rescue => _e
+          rescue StandardError => e
+            @warnings << "index.md: line for #{file_key_str.delete_suffix(".md")} not removed (#{e.message})"
           end
         end
 
@@ -97,6 +119,13 @@ module Samagotchi
 
       private
 
+      # A kept shared file's index line names the bundle that still has it.
+      def retag(scope, path, file_key, bundle)
+        IndexUpdater.update_index(scope, file_key.delete_suffix(".md"), File.size(path), source: bundle)
+      rescue StandardError => e
+        @warnings << "index.md: line for #{file_key.delete_suffix(".md")} not updated (#{e.message})"
+      end
+
       def resolve_target_dir(scope)
         MemoryPaths.scope_dir(scope) or raise UninstallError, "invalid scope: #{scope}"
       end

data/lib/samagotchi/plugin/context.rb

@@ -18,11 +18,14 @@ module Samagotchi
     # (chat messages, timeout:, max_tokens:, cancel_controller:) and returns
     # the answer text.
     # +messages_partial+ says whether +messages+ leaves out a running turn;
-    # +model_name+ and +state_dir+ are what ctx.sessions forks with.
+    # +model_name+ (the session's resolved model ref, live after /model) and
+    # +state_dir+ are what ctx.sessions forks with; +model_key+ is the
+    # model's memory overlay key (ctx.model, ctx.model_key).
     # +steer+ takes (text, label), +stop_turn+ and +stop_generation+
     # (reason, label), each true when it acted on a running turn.
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
-                      :ask_model, :model_name, :state_dir, :scratch, :steer, :stop_turn, :stop_generation, keyword_init: true)
+                      :ask_model, :model_name, :model_key, :state_dir, :scratch, :steer, :stop_turn, :stop_generation,
+                      keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -86,6 +89,15 @@ module Samagotchi
       # @return [String, nil] the session's id (nil before the first one)
       def session_id = @host.session_id.call
 
+      # @return [String, nil] the model the session runs on now: its
+      #   resolved ref ("host:id"), right after /model too
+      def model = @host.model_name&.call
+
+      # @return [String, nil] the model's memory overlay key
+      #   (`<name>.<key>.md`, ModelOverlay.key_for), as memory_write
+      #   current_model_only names it
+      def model_key = @host.model_key&.call
+
       # @return [String] the session's working directory
       def cwd = @host.cwd.call || Dir.pwd