samagotchi 0.8.1 → 0.10.0

data/lib/samagotchi/llm/native_tool_normalizer.rb

@@ -1,217 +1,19 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "../tools/execute"
-require_relative "../tools/read"
-require_relative "../tools/write"
-require_relative "../tools/memory"
-require_relative "../tools/edit"
-require_relative "../tools/task_create"
-require_relative "../tools/task_get"
-require_relative "../tools/task_list"
-require_relative "../tools/task_stop"
-require_relative "../tools/task_wait"
-require_relative "../tools/web_fetch"
-require_relative "../tools/register_reminder"
-require_relative "../tools/cancel_reminder"
-require_relative "../tools/list_reminders"
-require_relative "../tools/list_sessions"
-require_relative "../tools/send_note"
-require_relative "../tools/delegate"
-require_relative "../tools/delegate_result"
-require_relative "../tools/ask_user_question"
+require_relative "../tools/builtin_calls"
 
 module Samagotchi
   module LLM
     # Bridges a native tool call (an LLM::ToolCall from the chat adapter; any
-    # object with #name and #arguments) into samagotchi's internal tool-call shape that
-    # `KernelLoop#dispatch` consumes:
+    # object with #name and #arguments) into samagotchi's internal tool-call
+    # shape: its arguments read as a Hash, then Tools::BuiltinCalls builds
+    # the call, as it does for the Gemma and Qwen parsers.
     #
-    #   { name:, content:, path:, scope:, start_line:, end_line:, cwd:, env:, description: }
-    #
-    # The adapter hands you a *structured* `arguments` Hash (`.arguments` is a parsed
-    # Hash), while the internal `content` is a per-tool serialized text blob
-    # (e.g. `Edit` wants "<old>…</old><new>…</new>"; `Read` wants a `path`;
-    # `Execute` wants the command). Rather than re-architect every tool to accept
-    # structured args (huge blast radius), we rebuild the exact blob per tool so
-    # `dispatch` and every tool stay unchanged.
-    #
-    # Unknown tool names pass through untouched so `dispatch` renders its standard
-    # "unknown tool … available: …" error — the loop feeds that back like any tool
-    # result.
-    #
-    # This is the Phase-3 crux from Spike #4: the native→internal mapping is
-    # independent of how tools were driven in the request body.
+    # Unknown tool names pass through with their arguments on args:, so
+    # `dispatch` renders its standard "unknown tool … available: …" error —
+    # the loop feeds that back like any tool result.
     class NativeToolNormalizer
-      # Map each known tool NAME to a proc(args => internal-call-hash).
-      # Each proc receives the tool call's arguments (`.arguments` is a Hash of string→value)
-      # and returns the internal dispatch shape with every expected key present
-      # (missing values are nil).
-      #
-      # Args come back as strings from the wire (e.g. "start_line" => "1"); tools
-      # that read them do `.to_s.strip`, so we leave them as-is here and let the
-      # dispatch site coerce.
-      MAP = {
-        Tools::Execute::NAME => lambda { |args|
-          {
-            name: Tools::Execute::NAME,
-            content: args["command"].to_s,
-            path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: args["cwd"], env: args["env"]
-          }
-        },
-        Tools::Read::NAME => lambda { |args|
-          {
-            name: Tools::Read::NAME,
-            content: args["path"].to_s,
-            path: nil, scope: nil,
-            start_line: args["start_line"], end_line: args["end_line"],
-            cwd: nil, env: nil, description: nil,
-            args: args.is_a?(Hash) ? args : {}
-          }
-        },
-        Tools::Write::NAME => lambda { |args|
-          {
-            name: Tools::Write::NAME,
-            content: args["content"] || args["text"],
-            path: args["path"], scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil, description: nil
-          }
-        },
-        Tools::MemoryRead::NAME => lambda { |args|
-          {
-            name: Tools::MemoryRead::NAME,
-            content: args["name"].to_s,
-            path: nil, scope: args["scope"],
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil, description: nil
-          }
-        },
-        Tools::MemoryWrite::NAME => lambda { |args|
-          {
-            name: Tools::MemoryWrite::NAME,
-            content: args["content"] || args["text"] || args["body"],
-            path: args["name"], scope: args["scope"],
-            description: args["description"],
-            current_model_only: args["current_model_only"],
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil
-          }
-        },
-        Tools::Edit::NAME => lambda { |args|
-          old_text = args["old_text"] || args["old"]
-          new_text = args["new_text"] || args["new"]
-          {
-            name: Tools::Edit::NAME,
-            content: "<old>#{old_text}</old><new>#{new_text}</new>",
-            path: args["path"],
-            start_line: args["start_line"], end_line: args["end_line"],
-            scope: nil, cwd: nil, env: nil, description: nil
-          }
-        },
-        Tools::TaskCreate::NAME => lambda { |args|
-          {
-            name: Tools::TaskCreate::NAME,
-            content: args["command"].to_s,
-            path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: args["cwd"], env: args["env"], description: nil
-          }
-        },
-        Tools::TaskGet::NAME => lambda { |args|
-          {
-            name: Tools::TaskGet::NAME,
-            content: (args["id"] || args["task_id"]).to_s,
-            path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil, description: nil
-          }
-        },
-        Tools::TaskStop::NAME => lambda { |args|
-          {
-            name: Tools::TaskStop::NAME,
-            content: (args["id"] || args["task_id"]).to_s,
-            path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil, description: nil
-          }
-        },
-        Tools::TaskWait::NAME => lambda { |args|
-          {
-            name: Tools::TaskWait::NAME,
-            content: (args["id"] || args["task_id"]).to_s,
-            path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil,
-            timeout: args["timeout"], tail_lines: args["tail_lines"], done_pattern: args["done_pattern"],
-            description: nil
-          }
-        },
-        Tools::TaskList::NAME => lambda { |_args|
-          {
-            name: Tools::TaskList::NAME,
-            content: "", path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil, description: nil
-          }
-        },
-        Tools::WebFetch::NAME => lambda { |args|
-          {
-            name: Tools::WebFetch::NAME,
-            content: args["url"].to_s,
-            path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil, description: nil
-          }
-        },
-        Tools::RegisterReminder::NAME => lambda { |args|
-          {
-            name: Tools::RegisterReminder::NAME,
-            content: args["name"].to_s,
-            path: nil, scope: nil,
-            description: args["description"],
-            interval_minutes: args["interval_minutes"]
-          }
-        },
-        Tools::CancelReminder::NAME => lambda { |args|
-          { name: Tools::CancelReminder::NAME, content: args["name"].to_s, path: nil, scope: nil }
-        },
-        Tools::ListReminders::NAME => lambda { |_args|
-          { name: Tools::ListReminders::NAME, content: "", path: nil, scope: nil }
-        },
-        Tools::ListSessions::NAME => lambda { |args|
-          { name: Tools::ListSessions::NAME, content: "", path: nil, scope: nil, cwd: args["cwd"] }
-        },
-        Tools::SendNote::NAME => lambda { |args|
-          { name: Tools::SendNote::NAME, content: args["text"].to_s, path: nil, scope: nil, session: args["session"].to_s }
-        },
-        Tools::Delegate::NAME => lambda { |args|
-          { name: Tools::Delegate::NAME, content: args["task"].to_s, path: nil, scope: nil,
-            model: args["model"], session: args["session"], wait: args["wait"], timeout: args["timeout"] }
-        },
-        Tools::DelegateResult::NAME => lambda { |args|
-          { name: Tools::DelegateResult::NAME, content: "", path: nil, scope: nil,
-            session: args["session"], timeout: args["timeout"] }
-        },
-        Tools::AskUserQuestion::NAME => lambda { |args|
-          raw_opts = args["options"]
-          norm_opts = Samagotchi::Tools::AskUserQuestion.normalize_options_lenient(raw_opts)
-          norm_opts = raw_opts if norm_opts.empty? && raw_opts.is_a?(Array)
-          {
-            name: Tools::AskUserQuestion::NAME,
-            content: args["question"].to_s,
-            path: nil, scope: nil,
-            question: args["question"].to_s,
-            options: norm_opts.empty? ? raw_opts : norm_opts,
-            header: args["header"],
-            multi_select: args["multi_select"],
-            allow_freeform: args["allow_freeform"]
-          }
-        }
-      }.freeze
-
       class << self
         # Map a single native tool call (LLM::ToolCall) to the internal call hash.
         #
@@ -221,12 +23,7 @@ module Samagotchi
         def normalize(call)
           return nil if call.nil?
 
-          name = call.name.to_s
-          args = args_for(call)
-          proc = MAP[name]
-          return passthrough(name, args) unless proc
-
-          proc.call(args).merge(name: name)
+          Tools::BuiltinCalls.build(call.name.to_s, args_for(call))
         end
 
         # Map an Array of tool calls to internal call hashes (nils dropped).
@@ -252,25 +49,11 @@ module Samagotchi
         end
 
         def safe_json_parse(str)
-          JSON.parse(str)
+          parsed = JSON.parse(str)
+          parsed.is_a?(Hash) ? parsed : { "__raw__" => str }
         rescue JSON::ParserError
           { "__raw__" => str }
         end
-
-        # A registry (plugin) tool, or an unknown one: the arguments as args:
-        # (typed by the schema at dispatch), plus enough for `dispatch` to
-        # render the standard "unknown tool" error. `content` is the joined
-        # argument values (harmless; the unknown-tool branch ignores it).
-        def passthrough(name, args)
-          {
-            name: name,
-            content: args.is_a?(Hash) ? args.values.join(" ") : name,
-            path: nil, scope: nil,
-            start_line: nil, end_line: nil,
-            cwd: nil, env: nil, description: nil,
-            args: args.is_a?(Hash) ? args : {}
-          }
-        end
       end
     end
   end

data/lib/samagotchi/log_subscriber.rb

@@ -123,8 +123,12 @@ module Samagotchi
     def on_tool_call_completed(event)
       # A tool's output can be any bytes (invalid UTF-8 would fail the match).
       output = event[:output].to_s.scrub
+      # ms leaves out a guardrail approval wait (waited_ms, logged apart).
+      waited = event[:waited_ms].to_i
+      ms = since(@tool_started_at.delete([event[:iteration], event[:call_index]]))
+      ms = [ms - waited, 0].max if ms
       log(:info, :tool_call_completed, iteration: event[:iteration], tool: event[:tool],
-                                       ms: since(@tool_started_at.delete([event[:iteration], event[:call_index]])),
+                                       ms: ms, waited_ms: (waited if waited.positive?),
                                        output_chars: output.length, truncated: event[:output_truncated] || nil,
                                        error: tool_error?(output) || nil)
     end

data/lib/samagotchi/memory_bundle/builder.rb

@@ -14,8 +14,6 @@ module Samagotchi
     # Inverse of Installer: reads from the resolved scope directory,
     # computes SHA256 checksums, writes manifest.yml via Manifest.write,
     # and optionally zips/tars the staging directory.
-    #
-    # Reuses Installer.system_dir / project_dir_base overrides for test isolation.
     class Builder
       class BuildError < StandardError; end
 
@@ -291,18 +289,7 @@ module Samagotchi
       end
 
       def resolve_target_dir(scope)
-        case scope
-        when "system"
-          Samagotchi::MemoryBundle::Installer.system_dir
-        when "project"
-          if Samagotchi::MemoryBundle::Installer.project_dir_base_override
-            Samagotchi::MemoryBundle::Installer.project_dir_base
-          else
-            File.join(Samagotchi::MemoryBundle::Installer.project_dir_base, MemoryPaths.project_key)
-          end
-        else
-          raise BuildError, "invalid scope: #{scope}"
-        end
+        MemoryPaths.scope_dir(scope) or raise BuildError, "invalid scope: #{scope}"
       end
 
       def resolve_out_path(out_arg, default_name)

data/lib/samagotchi/memory_bundle/index_sync.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "index_updater"
+require_relative "../tools/memory"
+require_relative "../model_overlay"
+require_relative "../log"
+
+module Samagotchi
+  module MemoryBundle
+    # Keeps a memory's managed index.md line current when the file tools
+    # (write, edit) change it, as memory_write does: the ToolRunner calls
+    # .refresh after a write/edit that changed its file (one it could diff:
+    # a memory over 1 MB isn't refreshed). The line's description is kept.
+    #
+    # Only a *.md right in the project or system memories dir (the dirs
+    # memory_write writes to) counts: not index.md, not a hidden file, not a
+    # model overlay (<name>.<key>.md next to its <name>.md; a memory whose
+    # name has a dot and a sibling of the same stem reads as an overlay too,
+    # a leftover ambiguity). Writes into another project's folder and
+    # execute's writes aren't seen.
+    module IndexSync
+      SCOPES = %w[project system].freeze
+
+      # @param path [String] the file write/edit changed
+      # @return [Boolean] whether an index line was written
+      def self.refresh(path)
+        path = File.expand_path(path.to_s)
+        scope = memory_scope(path)
+        return false unless scope && File.file?(path)
+
+        name = File.basename(path, ".md")
+        return false if overlay?(path, name)
+
+        IndexUpdater.update_index(scope, name, File.size(path), nil)
+      rescue StandardError => e
+        Log.warn(:memory, "index_sync_failed", path: path, error: "#{e.class}: #{e.message}")
+        false
+      end
+
+      # "project" or "system" when +path+ is a memory's file (or an
+      # overlay's): a *.md right in that scope's memories dir, not index.md,
+      # not hidden, not a symlink. nil otherwise. The guardrails' outside_repo
+      # uses it too: write/edit there is what memory_write does. A symlink
+      # isn't: write/edit follow it to wherever it points, memory_write
+      # replaces the link.
+      def self.memory_scope(path)
+        path = File.expand_path(path.to_s)
+        name = File.basename(path, ".md")
+        return nil unless File.extname(path) == ".md"
+        return nil if name == IndexUpdater::MEMORY_INDEX || name.start_with?(".") || File.symlink?(path)
+
+        dir = real(File.dirname(path))
+        SCOPES.find { |s| real(Tools::MemoryRead.memories_dir(s)) == dir }
+      rescue StandardError
+        nil
+      end
+
+      def self.overlay?(path, name)
+        match = File.basename(path).match(ModelOverlay::OVERLAY_SUFFIX_PATTERN)
+        return false unless match
+
+        base = name.delete_suffix(".#{match[1]}")
+        File.file?(File.join(File.dirname(path), "#{base}.md"))
+      end
+
+      def self.real(dir)
+        File.realpath(dir)
+      rescue SystemCallError
+        File.expand_path(dir)
+      end
+    end
+  end
+end

data/lib/samagotchi/memory_bundle/index_updater.rb

@@ -7,22 +7,9 @@ module Samagotchi
   module MemoryBundle
     # Updates the scoped index.md for a single entry, locked and atomically.
     # Used by Installer (P3) to keep index.md in sync.
-    # Delegates to MemoryRead.memories_dir for test-isolated paths.
     module IndexUpdater
       MEMORY_INDEX = "index"
       LOCK_FILE = ".index.lock"
-      def self.system_dir_override
-        @system_dir_override
-      end
-      def self.system_dir_override=(val)
-        @system_dir_override = val
-      end
-      def self.project_dir_base_override
-        @project_dir_base_override
-      end
-      def self.project_dir_base_override=(val)
-        @project_dir_base_override = val
-      end
       def self.update_index(scope, entry_name, byte_count, description = nil)
         index_path = index_path_for(scope)
         return true unless index_path
@@ -93,21 +80,8 @@ module Samagotchi
         Date.today.iso8601
       end
       def self.index_path_for(scope)
-        normalized = scope.to_s.strip
-        normalized = "system" if normalized.empty?
-        base_dir = case normalized
-                   when "system"
-                     system_dir_override || MemoryPaths.system_dir
-                   when "project"
-                     if project_dir_base_override
-                       File.join(project_dir_base_override, MemoryPaths.project_key)
-                     else
-                       MemoryPaths.project_dir
-                     end
-                   else
-                     return nil
-                   end
-        File.join(base_dir, "#{MEMORY_INDEX}.md")
+        base_dir = MemoryPaths.scope_dir(scope.to_s.strip)
+        base_dir && File.join(base_dir, "#{MEMORY_INDEX}.md")
       end
     end
   end

data/lib/samagotchi/memory_bundle/installer.rb

@@ -29,18 +29,6 @@ module Samagotchi
 
       attr_reader :results, :warnings, :placeholder_warnings, :conflicts
 
-      class << self
-        attr_accessor :system_dir_override, :project_dir_base_override
-
-        def system_dir
-          system_dir_override || MemoryPaths.system_dir
-        end
-
-        def project_dir_base
-          project_dir_base_override || MemoryPaths.projects_dir
-        end
-      end
-
       def initialize(source:, name:, scope: nil, force: false, strict: true, upgrade: false, dry_run: false)
         @source = source
         @name = name
@@ -53,9 +41,6 @@ module Samagotchi
         @warnings = []
         @placeholder_warnings = []
         @conflicts = {}
-        # Propagate scope overrides so IndexUpdater resolves the correct directories.
-        IndexUpdater.system_dir_override = self.class.system_dir_override
-        IndexUpdater.project_dir_base_override = self.class.project_dir_base_override
       end
 
       def run
@@ -86,6 +71,8 @@ module Samagotchi
         all_files_in_bundle = []
         provenance = Provenance.new(name: @name)
         existing_provenance = provenance.read
+        # A plain install over an installed bundle: summary points at upgrade.
+        @reinstall = existing_provenance && !@upgrade && !@force && !@dry_run
 
         Dir.glob(File.join(normalized_dir, "*.md")).each do |file_path|
           file_key = File.basename(file_path)
@@ -125,12 +112,17 @@ module Samagotchi
                 classification = Merger.classify(base_path: base_path, current_path: target_path, incoming_path: file_path)
                 @results[file_key] = { status: classification.to_s }
                 @conflicts[file_key] = { base: base_path, current: target_path, incoming: file_path } if classification == :conflict
+              elsif FileUtils.identical?(file_path, target_path)
+                @results[file_key] = { status: "skipped", reason: "already up to date" }
               else
                 @results[file_key] = { status: "would_skip" }
               end
             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)"
@@ -252,13 +244,19 @@ module Samagotchi
         if @dry_run
           incoming_rules.each { |src| @results["guardrails/#{File.basename(src)}"] = { status: "would_install" } }
         else
+          # Same bytes as installed: reported as up to date, not "Installed".
+          unchanged = incoming_rules.select do |src|
+            dest = File.join(guardrails_target, File.basename(src))
+            File.file?(dest) && FileUtils.identical?(src, dest)
+          end
           FileUtils.rm_rf(guardrails_target)
           unless incoming_rules.empty?
             FileUtils.mkdir_p(guardrails_target)
             incoming_rules.each do |src|
               dest = File.join(guardrails_target, File.basename(src))
               FileUtils.cp(src, dest)
-              @results["guardrails/#{File.basename(src)}"] = { status: "installed" }
+              @results["guardrails/#{File.basename(src)}"] =
+                unchanged.include?(src) ? { status: "skipped", reason: "already up to date" } : { status: "installed" }
               guardrail_files_for_provenance[File.basename(src)] = dest
             end
           end
@@ -278,7 +276,8 @@ module Samagotchi
           all_files_in_bundle.each do |file_key|
             next if @conflicts.key?(file_key)
             status = @results[file_key] ? @results[file_key][:status].to_s : nil
-            next if %w[kept kept_pruned fast_forward updated].include?(status)
+            # skipped: not copied, so a local edit isn't a bad download.
+            next if %w[kept kept_pruned fast_forward updated skipped].include?(status)
             # For dry-run, fast_forward would appear as "fast_forward", updated not yet
             target_path = File.join(target_dir, file_key)
             next unless File.exist?(target_path)
@@ -340,7 +339,13 @@ module Samagotchi
           else
             all_files_in_bundle.each do |file_key|
               target_path = File.join(target_dir, file_key)
-              provenance_files[file_key] = target_path if File.exist?(target_path)
+              next unless File.exist?(target_path)
+
+              # Skipped for a local edit: keep the installed base, so the
+              # next upgrade still sees the edit (not a fast-forward over it).
+              base_path = provenance.base_path(file_key)
+              kept = existing_provenance && @results.dig(file_key, :reason) == "already exists" && File.exist?(base_path)
+              provenance_files[file_key] = kept ? base_path : target_path
             end
           end
           # Build hooks metadata for provenance
@@ -409,6 +414,7 @@ module Samagotchi
         lines << "Conflicts: #{conflicts.join(', ')}" unless conflicts.empty?
         lines.concat(@warnings) unless @warnings.empty?
         lines.concat(@placeholder_warnings) unless @placeholder_warnings.empty?
+        lines << "#{@name} is already installed; `chi bundle upgrade #{@name}` updates it and keeps local edits" if @reinstall
 
         lines.any? ? lines.join("\n") : "No files to install."
       end
@@ -510,18 +516,7 @@ module Samagotchi
       end
 
       def resolve_target_dir(scope)
-        case scope
-        when "system", ""
-          self.class.system_dir
-        when "project"
-          if self.class.project_dir_base_override
-            self.class.project_dir_base
-          else
-            File.join(self.class.project_dir_base, MemoryPaths.project_key)
-          end
-        else
-          raise InstallError, "invalid scope: #{scope}"
-        end
+        MemoryPaths.scope_dir(scope) or raise InstallError, "invalid scope: #{scope}"
       end
     end
   end

data/lib/samagotchi/memory_bundle/provenance.rb

@@ -14,12 +14,8 @@ module Samagotchi
     #   manifest.json — metadata about the install (merged on reinstall)
     #   bases/        — snapshots of every file as installed (for 3-way merge later)
     class Provenance
-      class << self
-        attr_accessor :bundles_dir_override
-
-        def bundles_dir
-          bundles_dir_override || MemoryPaths.bundles_dir
-        end
+      def self.bundles_dir
+        MemoryPaths.bundles_dir
       end
 
       attr_reader :name, :bundle_dir

data/lib/samagotchi/memory_bundle/status.rb

@@ -80,20 +80,7 @@ module Samagotchi
       end
 
       def self.resolve_target_dir(scope)
-        case scope
-        when "system"
-          Samagotchi::MemoryBundle::Installer.system_dir
-        when "project"
-          base = Samagotchi::MemoryBundle::Installer.project_dir_base
-          # If override set via Installer, use it; else compute hash
-          if Samagotchi::MemoryBundle::Installer.project_dir_base_override
-            base
-          else
-            File.join(base, MemoryPaths.project_key)
-          end
-        else
-          Samagotchi::MemoryBundle::Installer.system_dir
-        end
+        MemoryPaths.scope_dir(scope) || MemoryPaths.system_dir
       end
 
       # Index lines name the entry without ".md" (Installer#update_target_index,

data/lib/samagotchi/memory_bundle/system_bundle.rb

@@ -160,7 +160,7 @@ module Samagotchi
       # back via the Installer (which classifies it as :install), without a
       # full reinstall.
       def verify_files_present(gem_manifest, version, dry_run)
-        target_dir = Installer.system_dir
+        target_dir = MemoryPaths.system_dir
         missing = gem_manifest.files.keys.any? { |k| !File.exist?(File.join(target_dir, k)) }
         return result(:up_to_date, from: version, to: version) unless missing
         return result(:restored, from: version, to: version) if dry_run
@@ -174,7 +174,7 @@ module Samagotchi
       def conflicting(gem_manifest)
         provenance = Provenance.new(name: BUNDLE_NAME)
         gem_manifest.files.keys.map(&:to_s).sort.select do |key|
-          Merger.classify(base_path: provenance.base_path(key), current_path: File.join(Installer.system_dir, 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
       end

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -13,24 +13,12 @@ module Samagotchi
 
       attr_reader :warnings, :removed_files
 
-      class << self
-        attr_accessor :system_dir_override, :project_dir_base_override
-        def system_dir
-          system_dir_override || MemoryPaths.system_dir
-        end
-        def project_dir_base
-          project_dir_base_override || MemoryPaths.projects_dir
-        end
-      end
-
       def initialize(name:, scope: nil, force: false)
         @name = name
         @scope = scope&.to_s&.strip&.downcase
         @force = force
         @warnings = []
         @removed_files = []
-        IndexUpdater.system_dir_override = self.class.system_dir_override
-        IndexUpdater.project_dir_base_override = self.class.project_dir_base_override
       end
 
       def run
@@ -110,18 +98,7 @@ module Samagotchi
       private
 
       def resolve_target_dir(scope)
-        case scope
-        when "system", ""
-          self.class.system_dir
-        when "project"
-          if self.class.project_dir_base_override
-            self.class.project_dir_base
-          else
-            File.join(self.class.project_dir_base, MemoryPaths.project_key)
-          end
-        else
-          raise UninstallError, "invalid scope: #{scope}"
-        end
+        MemoryPaths.scope_dir(scope) or raise UninstallError, "invalid scope: #{scope}"
       end
     end
   end

data/lib/samagotchi/memory_paths.rb

@@ -94,6 +94,16 @@ module Samagotchi
       File.join(projects_dir(env: env), project_key(cwd))
     end
 
+    # The folder of a memory scope: "system" (or blank) or "project"; nil for
+    # anything else. Every scope→folder lookup (bundle install/uninstall/build/
+    # status, index.md updates, the memory tools) resolves here.
+    def scope_dir(scope, env: ENV, cwd: Dir.pwd)
+      case scope.to_s
+      when "system", "" then system_dir(env: env)
+      when "project" then project_dir(env: env, cwd: cwd)
+      end
+    end
+
     def bundles_dir(env: ENV)
       File.join(system_dir(env: env), ".bundles")
     end