claude_swarm 1.0.9 → 1.0.11

data/lib/swarm_cli/ui/icons.rb

@@ -31,29 +31,6 @@ module SwarmCLI
       ARROW_RIGHT = "→"
       BULLET = "•"
       COMPRESS = "🗜️"
-
-      # All icons as hash for backward compatibility
-      ALL = {
-        thinking: THINKING,
-        response: RESPONSE,
-        success: SUCCESS,
-        error: ERROR,
-        info: INFO,
-        warning: WARNING,
-        agent: AGENT,
-        tool: TOOL,
-        delegate: DELEGATE,
-        result: RESULT,
-        hook: HOOK,
-        llm: LLM,
-        tokens: TOKENS,
-        cost: COST,
-        time: TIME,
-        sparkles: SPARKLES,
-        arrow_right: ARROW_RIGHT,
-        bullet: BULLET,
-        compress: COMPRESS,
-      }.freeze
     end
   end
 end

data/lib/swarm_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwarmCLI
-  VERSION = "2.1.3"
+  VERSION = "2.1.7"
 end

data/lib/swarm_memory/adapters/filesystem_adapter.rb

@@ -93,10 +93,10 @@ module SwarmMemory
                 "Clear old entries or use smaller content."
             end
 
-            # Strip .md extension and flatten path for disk storage
-            # "concepts/ruby/classes.md" → "concepts--ruby--classes"
+            # Strip .md extension for disk storage
+            # "concepts/ruby/classes.md" → "concepts/ruby/classes"
             base_path = file_path.sub(/\.md\z/, "")
-            disk_path = flatten_path(base_path)
+            disk_path = base_path
 
             # 1. Write content to .md file (stored exactly as provided)
             md_file = File.join(@directory, "#{disk_path}.md")
@@ -162,9 +162,9 @@ module SwarmMemory
           return entry.content
         end
 
-        # Strip .md extension and flatten path
+        # Strip .md extension
         base_path = file_path.sub(/\.md\z/, "")
-        disk_path = flatten_path(base_path)
+        disk_path = base_path
         md_file = File.join(@directory, "#{disk_path}.md")
 
         raise ArgumentError, "memory://#{file_path} not found" unless File.exist?(md_file)
@@ -189,9 +189,9 @@ module SwarmMemory
           return load_virtual_entry(file_path)
         end
 
-        # Strip .md extension and flatten path
+        # Strip .md extension
         base_path = file_path.sub(/\.md\z/, "")
-        disk_path = flatten_path(base_path)
+        disk_path = base_path
         md_file = File.join(@directory, "#{disk_path}.md")
         yaml_file = File.join(@directory, "#{disk_path}.yml")
 
@@ -230,9 +230,9 @@ module SwarmMemory
           @semaphore.acquire do
             raise ArgumentError, "file_path is required" if file_path.nil? || file_path.to_s.strip.empty?
 
-            # Strip .md extension and flatten path
+            # Strip .md extension
             base_path = file_path.sub(/\.md\z/, "")
-            disk_path = flatten_path(base_path)
+            disk_path = base_path
             md_file = File.join(@directory, "#{disk_path}.md")
 
             raise ArgumentError, "memory://#{file_path} not found" unless File.exist?(md_file)
@@ -500,29 +500,6 @@ module SwarmMemory
         )
       end
 
-      # Flatten path for disk storage
-      # "concepts/ruby/classes" → "concepts--ruby--classes"
-      #
-      # @param logical_path [String] Logical path with slashes
-      # @return [String] Flattened path with --
-      # Identity function - paths are now stored hierarchically
-      # Kept for backward compatibility during transition
-      #
-      # @param logical_path [String] Logical path
-      # @return [String] Same path (no flattening)
-      def flatten_path(logical_path)
-        logical_path
-      end
-
-      # Identity function - paths are now stored hierarchically
-      # Kept for backward compatibility during transition
-      #
-      # @param disk_path [String] Disk path
-      # @return [String] Same path (no unflattening)
-      def unflatten_path(disk_path)
-        disk_path
-      end
-
       # Check if content is a stub (redirect)
       #
       # @param content [String] File content
@@ -566,7 +543,7 @@ module SwarmMemory
       # @return [void]
       def increment_hits(file_path)
         base_path = file_path.sub(/\.md\z/, "")
-        disk_path = flatten_path(base_path)
+        disk_path = base_path
         yaml_file = File.join(@directory, "#{disk_path}.yml")
         return unless File.exist?(yaml_file)
 
@@ -587,7 +564,7 @@ module SwarmMemory
       # @return [Integer] Size in bytes
       def get_entry_size(file_path)
         base_path = file_path.sub(/\.md\z/, "")
-        disk_path = flatten_path(base_path)
+        disk_path = base_path
         yaml_file = File.join(@directory, "#{disk_path}.yml")
 
         if File.exist?(yaml_file)

data/lib/swarm_memory/core/semantic_index.rb

@@ -181,6 +181,9 @@ module SwarmMemory
 
       # Calculate hybrid scores combining semantic similarity and keyword matching
       #
+      # When keyword_score is 0 (no tag matches), falls back to pure semantic scoring
+      # to avoid penalizing results that have excellent semantic matches but no tag overlap.
+      #
       # @param results [Array<Hash>] Results with semantic :similarity scores
       # @param query_keywords [Array<String>] Keywords from query
       # @return [Array<Hash>] Results with updated :similarity (hybrid score) and debug info
@@ -189,8 +192,13 @@ module SwarmMemory
           semantic_score = result[:similarity]
           keyword_score = calculate_keyword_score(result, query_keywords)
 
-          # Hybrid score: weighted combination
-          hybrid_score = (@semantic_weight * semantic_score) + (@keyword_weight * keyword_score)
+          # Fallback to pure semantic when no keyword matches
+          # This prevents penalizing results with excellent semantic matches but no tag overlap
+          hybrid_score = if keyword_score.zero?
+            semantic_score
+          else
+            (@semantic_weight * semantic_score) + (@keyword_weight * keyword_score)
+          end
 
           # Update result with hybrid score and debug info
           result.merge(

data/lib/swarm_memory/core/storage.rb

@@ -18,7 +18,9 @@ module SwarmMemory
       #
       # @param adapter [Adapters::Base] Storage adapter
       # @param embedder [Embeddings::Embedder, nil] Optional embedder for semantic search
-      def initialize(adapter:, embedder: nil)
+      # @param semantic_weight [Float, nil] Weight for semantic similarity in hybrid search (0.0-1.0)
+      # @param keyword_weight [Float, nil] Weight for keyword matching in hybrid search (0.0-1.0)
+      def initialize(adapter:, embedder: nil, semantic_weight: nil, keyword_weight: nil)
         raise ArgumentError, "adapter is required" unless adapter.is_a?(Adapters::Base)
 
         @adapter = adapter
@@ -26,7 +28,10 @@ module SwarmMemory
 
         # Create semantic index if embedder is provided
         @semantic_index = if embedder
-          SemanticIndex.new(adapter: adapter, embedder: embedder)
+          index_options = { adapter: adapter, embedder: embedder }
+          index_options[:semantic_weight] = semantic_weight if semantic_weight
+          index_options[:keyword_weight] = keyword_weight if keyword_weight
+          SemanticIndex.new(**index_options)
         end
       end
 

data/lib/swarm_memory/dsl/memory_config.rb

@@ -84,6 +84,43 @@ module SwarmMemory
         @mode = value.to_sym
       end
 
+      # DSL method to set/get semantic weight for hybrid search
+      #
+      # Controls how much semantic (embedding) similarity affects search results.
+      # Default is 0.5 (50%). Set to 1.0 for pure semantic search.
+      #
+      # @param value [Float, nil] Weight between 0.0 and 1.0
+      # @return [Float, nil] Current semantic weight
+      #
+      # @example Pure semantic search (no keyword penalty)
+      #   semantic_weight 1.0
+      #   keyword_weight 0.0
+      def semantic_weight(value = nil)
+        if value.nil?
+          @adapter_options[:semantic_weight]
+        else
+          @adapter_options[:semantic_weight] = value.to_f
+        end
+      end
+
+      # DSL method to set/get keyword weight for hybrid search
+      #
+      # Controls how much keyword (tag) matching affects search results.
+      # Default is 0.5 (50%). Set to 0.0 to disable keyword matching.
+      #
+      # @param value [Float, nil] Weight between 0.0 and 1.0
+      # @return [Float, nil] Current keyword weight
+      #
+      # @example Disable keyword matching
+      #   keyword_weight 0.0
+      def keyword_weight(value = nil)
+        if value.nil?
+          @adapter_options[:keyword_weight]
+        else
+          @adapter_options[:keyword_weight] = value.to_f
+        end
+      end
+
       # Check if memory is enabled
       #
       # @return [Boolean] True if adapter is configured with required options

data/lib/swarm_memory/integration/sdk_plugin.rb

@@ -22,6 +22,9 @@ module SwarmMemory
         # Track memory mode for each agent: { agent_name => mode }
         # Modes: :assistant (default), :retrieval, :researcher
         @modes = {}
+        # Track threshold configuration for each agent: { agent_name => config }
+        # Enables per-adapter threshold tuning with ENV fallback
+        @threshold_configs = {}
       end
 
       # Plugin identifier
@@ -49,7 +52,6 @@ module SwarmMemory
           :MemoryGrep,
           :MemoryWrite,
           :MemoryEdit,
-          :MemoryMultiEdit,
           :MemoryDelete,
           :MemoryDefrag,
         ]
@@ -75,7 +77,6 @@ module SwarmMemory
             :MemoryGrep,
             :MemoryWrite,
             :MemoryEdit,
-            :MemoryMultiEdit,
             :MemoryDelete,
             :MemoryDefrag,
           ]
@@ -109,10 +110,12 @@ module SwarmMemory
           # MemoryConfig object (from DSL)
           [config.adapter_type, config.adapter_options]
         elsif config.is_a?(Hash)
-          # Hash (from YAML)
+          # Hash (from YAML) - symbolize keys for adapter compatibility
           adapter = (config[:adapter] || config["adapter"] || :filesystem).to_sym
-          options = config.reject { |k, _v| k == :adapter || k == "adapter" || k == :mode || k == "mode" }
-          [adapter, options]
+          options = config.reject { |k, _v| [:adapter, "adapter", :mode, "mode"].include?(k) }
+          # Symbolize keys so adapter receives keyword arguments correctly
+          symbolized_options = options.transform_keys { |k| k.to_s.to_sym }
+          [adapter, symbolized_options]
         else
           raise SwarmSDK::ConfigurationError, "Invalid memory configuration for #{agent_name}"
         end
@@ -124,7 +127,17 @@ module SwarmMemory
           raise SwarmSDK::ConfigurationError, "#{e.message} for agent #{agent_name}"
         end
 
-        # Instantiate adapter with options
+        # Extract hybrid search weights and other SDK-level config (before passing to adapter)
+        # Keys are already symbolized at this point
+        semantic_weight = adapter_options.delete(:semantic_weight)
+        keyword_weight = adapter_options.delete(:keyword_weight)
+
+        # Remove other SDK-level threshold configs that shouldn't go to adapter
+        adapter_options.delete(:discovery_threshold)
+        adapter_options.delete(:discovery_threshold_short)
+        adapter_options.delete(:adaptive_word_cutoff)
+
+        # Instantiate adapter with options (weights removed, adapter doesn't need them)
         # Note: Adapter is responsible for validating its own requirements
         begin
           adapter = adapter_class.new(**adapter_options)
@@ -136,8 +149,13 @@ module SwarmMemory
         # Create embedder for semantic search
         embedder = Embeddings::InformersEmbedder.new
 
-        # Create storage with embedder (enables semantic features)
-        Core::Storage.new(adapter: adapter, embedder: embedder)
+        # Create storage with embedder and hybrid search weights
+        Core::Storage.new(
+          adapter: adapter,
+          embedder: embedder,
+          semantic_weight: semantic_weight,
+          keyword_weight: keyword_weight,
+        )
       end
 
       # Parse memory configuration
@@ -156,7 +174,7 @@ module SwarmMemory
       # @return [String] Memory prompt contribution
       def system_prompt_contribution(agent_definition:, storage:)
         # Extract mode from memory config
-        memory_config = agent_definition.memory
+        memory_config = agent_definition.plugin_config(:memory)
         mode = if memory_config.is_a?(SwarmMemory::DSL::MemoryConfig)
           memory_config.mode # MemoryConfig object from DSL
         elsif memory_config.respond_to?(:mode)
@@ -199,25 +217,126 @@ module SwarmMemory
         end
       end
 
-      # Check if storage should be created for this agent
+      # Check if memory is configured for this agent
+      #
+      # Delegates adapter-specific validation to the adapter itself.
+      # Filesystem adapter requires 'directory', custom adapters may use other keys.
       #
       # @param agent_definition [Agent::Definition] Agent definition
-      # @return [Boolean] True if agent has memory configuration
-      def storage_enabled?(agent_definition)
-        agent_definition.memory_enabled?
+      # @return [Boolean] True if agent has valid memory configuration
+      def memory_configured?(agent_definition)
+        memory_config = agent_definition.plugin_config(:memory)
+        return false if memory_config.nil?
+
+        # MemoryConfig object (from DSL) - delegates to its enabled? method
+        return memory_config.enabled? if memory_config.respond_to?(:enabled?)
+
+        # Hash (from YAML)
+        return false unless memory_config.is_a?(Hash)
+        return false if memory_config.empty?
+
+        adapter = (memory_config[:adapter] || memory_config["adapter"] || :filesystem).to_sym
+
+        case adapter
+        when :filesystem
+          # Filesystem adapter requires directory
+          directory = memory_config[:directory] || memory_config["directory"]
+          !directory.nil? && !directory.to_s.strip.empty?
+        else
+          # Custom adapters: presence of config is sufficient
+          # Adapter will validate its own requirements during initialization
+          true
+        end
       end
 
       # Contribute to agent serialization
       #
-      # Preserves memory configuration when agents are cloned (e.g., in NodeOrchestrator).
+      # Preserves memory configuration when agents are cloned (e.g., in Workflow).
       # This allows memory configuration to persist across node transitions.
       #
       # @param agent_definition [Agent::Definition] Agent definition
       # @return [Hash] Memory config to include in to_h
       def serialize_config(agent_definition:)
-        return {} unless agent_definition.memory
+        memory_config = agent_definition.plugin_config(:memory)
+        return {} unless memory_config
 
-        { memory: agent_definition.memory }
+        { memory: memory_config }
+      end
+
+      # Snapshot plugin-specific state for an agent
+      #
+      # Captures memory read tracking state for session persistence.
+      # This allows agents to remember which memory entries they've read
+      # across sessions.
+      #
+      # @param agent_name [Symbol] Agent identifier
+      # @return [Hash] Plugin-specific state
+      def snapshot_agent_state(agent_name)
+        entries_with_digests = Core::StorageReadTracker.get_read_entries(agent_name)
+        return {} if entries_with_digests.empty?
+
+        { read_entries: entries_with_digests }
+      end
+
+      # Restore plugin-specific state for an agent
+      #
+      # Restores memory read tracking state from snapshot.
+      # This is idempotent - calling multiple times with same state
+      # produces the same result.
+      #
+      # @param agent_name [Symbol] Agent identifier
+      # @param state [Hash] Previously snapshotted state (with symbol keys)
+      # @return [void]
+      def restore_agent_state(agent_name, state)
+        entries = state[:read_entries] || state["read_entries"]
+        return unless entries
+
+        Core::StorageReadTracker.restore_read_entries(agent_name, entries)
+      end
+
+      # Get digest for a memory tool result
+      #
+      # Returns the digest for a MemoryRead tool call, enabling change detection
+      # hooks to know if a memory entry has been modified since last read.
+      #
+      # @param agent_name [Symbol] Agent identifier
+      # @param tool_name [String] Name of the tool
+      # @param path [String] Path of the memory entry
+      # @return [String, nil] Digest string or nil if not a memory tool
+      def get_tool_result_digest(agent_name:, tool_name:, path:)
+        return unless tool_name == "MemoryRead"
+
+        Core::StorageReadTracker.get_read_entries(agent_name)[path]
+      end
+
+      # Translate YAML configuration into DSL calls
+      #
+      # Called during YAML-to-DSL translation. Handles memory-specific YAML
+      # configuration and translates it into DSL method calls on the builder.
+      #
+      # @param builder [Agent::Builder] Builder instance (self in DSL context)
+      # @param agent_config [Hash] Full agent config from YAML
+      # @return [void]
+      def translate_yaml_config(builder, agent_config)
+        memory_config = agent_config[:memory]
+        return unless memory_config
+
+        builder.instance_eval do
+          memory do
+            # Standard options
+            directory(memory_config[:directory]) if memory_config[:directory]
+            adapter(memory_config[:adapter]) if memory_config[:adapter]
+            mode(memory_config[:mode]) if memory_config[:mode]
+
+            # Pass through all custom adapter options
+            # Handle both symbol and string keys (YAML may have either)
+            standard_keys = [:directory, :adapter, :mode, "directory", "adapter", "mode"]
+            custom_keys = memory_config.keys - standard_keys
+            custom_keys.each do |key|
+              option(key.to_sym, memory_config[key]) # Normalize to symbol
+            end
+          end
+        end
       end
 
       # Lifecycle: Agent initialized
@@ -239,7 +358,7 @@ module SwarmMemory
         return unless storage # Only proceed if memory is enabled for this agent
 
         # Extract mode from memory config
-        memory_config = agent_definition.memory
+        memory_config = agent_definition.plugin_config(:memory)
         mode = if memory_config.is_a?(SwarmMemory::DSL::MemoryConfig)
           memory_config.mode # MemoryConfig object from DSL
         elsif memory_config.respond_to?(:mode)
@@ -256,6 +375,7 @@ module SwarmMemory
         # Store storage and mode using BASE NAME
         @storages[base_name] = storage # ← Changed from agent_name to base_name
         @modes[base_name] = mode # ← Changed from agent_name to base_name
+        @threshold_configs[base_name] = extract_threshold_config(memory_config)
 
         # Get mode-specific tools
         allowed_tools = tools_for_mode(mode)
@@ -281,7 +401,7 @@ module SwarmMemory
             agent_definition: agent_definition,
           )
 
-          agent.with_tool(load_skill_tool)
+          agent.add_tool(load_skill_tool)
         end
 
         # Mark mode-specific memory tools + LoadSkill as immutable
@@ -304,20 +424,27 @@ module SwarmMemory
         # V7.0: Extract base name for storage lookup (delegation instances share storage)
         base_name = agent_name.to_s.split("@").first.to_sym
         storage = @storages[base_name] # ← Changed from agent_name to base_name
+        config = @threshold_configs[base_name] || {}
 
         return [] unless storage&.semantic_index
         return [] if prompt.nil? || prompt.empty?
 
         # Adaptive threshold based on query length
         # Short queries use lower threshold as they have less semantic richness
-        # Optimal: cutoff=10 words, short=0.25, normal=0.35 (discovered via systematic evaluation)
+        # Fallback chain: config → ENV → default
         word_count = prompt.split.size
-        word_cutoff = (ENV["SWARM_MEMORY_ADAPTIVE_WORD_CUTOFF"] || "10").to_i
+        word_cutoff = config[:adaptive_word_cutoff] ||
+          ENV["SWARM_MEMORY_ADAPTIVE_WORD_CUTOFF"]&.to_i ||
+          10
 
         threshold = if word_count < word_cutoff
-          (ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD_SHORT"] || "0.25").to_f
+          config[:discovery_threshold_short] ||
+            ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD_SHORT"]&.to_f ||
+            0.25
         else
-          (ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD"] || "0.35").to_f
+          config[:discovery_threshold] ||
+            ENV["SWARM_MEMORY_DISCOVERY_THRESHOLD"]&.to_f ||
+            0.35
         end
         reminders = []
 
@@ -402,9 +529,15 @@ module SwarmMemory
           }
         end
 
-        # Get actual weights being used (from ENV or defaults)
-        semantic_weight = (ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"] || "0.5").to_f
-        keyword_weight = (ENV["SWARM_MEMORY_KEYWORD_WEIGHT"] || "0.5").to_f
+        # Get actual weights being used (fallback chain: config → ENV → defaults)
+        base_name = agent_name.to_s.split("@").first.to_sym
+        config = @threshold_configs[base_name] || {}
+        semantic_weight = config[:semantic_weight] ||
+          ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"]&.to_f ||
+          0.5
+        keyword_weight = config[:keyword_weight] ||
+          ENV["SWARM_MEMORY_KEYWORD_WEIGHT"]&.to_f ||
+          0.5
 
         SwarmSDK::LogStream.emit(
           type: "semantic_skill_search",
@@ -465,9 +598,15 @@ module SwarmMemory
           }
         end
 
-        # Get actual weights being used (from ENV or defaults)
-        semantic_weight = (ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"] || "0.5").to_f
-        keyword_weight = (ENV["SWARM_MEMORY_KEYWORD_WEIGHT"] || "0.5").to_f
+        # Get actual weights being used (fallback chain: config → ENV → defaults)
+        base_name = agent_name.to_s.split("@").first.to_sym
+        config = @threshold_configs[base_name] || {}
+        semantic_weight = config[:semantic_weight] ||
+          ENV["SWARM_MEMORY_SEMANTIC_WEIGHT"]&.to_f ||
+          0.5
+        keyword_weight = config[:keyword_weight] ||
+          ENV["SWARM_MEMORY_KEYWORD_WEIGHT"]&.to_f ||
+          0.5
 
         SwarmSDK::LogStream.emit(
           type: "semantic_memory_search",
@@ -546,6 +685,40 @@ module SwarmMemory
 
         reminder
       end
+
+      # Extract threshold configuration from memory config
+      #
+      # Supports both MemoryConfig objects (from DSL) and Hash configs (from YAML).
+      # Extracts semantic search thresholds and hybrid search weights.
+      #
+      # @param memory_config [MemoryConfig, Hash, nil] Memory configuration
+      # @return [Hash] Threshold config with symbol keys
+      def extract_threshold_config(memory_config)
+        return {} unless memory_config
+
+        threshold_keys = [
+          :discovery_threshold,
+          :discovery_threshold_short,
+          :adaptive_word_cutoff,
+          :semantic_weight,
+          :keyword_weight,
+        ]
+
+        if memory_config.respond_to?(:adapter_options)
+          # MemoryConfig object (from DSL)
+          memory_config.adapter_options.slice(*threshold_keys)
+        elsif memory_config.is_a?(Hash)
+          # Hash (from YAML) - handle both symbol and string keys
+          result = {}
+          threshold_keys.each do |key|
+            value = memory_config[key] || memory_config[key.to_s]
+            result[key] = value if value
+          end
+          result
+        else
+          {}
+        end
+      end
     end
   end
 end

data/lib/swarm_memory/optimization/defragmenter.rb

@@ -191,7 +191,7 @@ module SwarmMemory
             "  Semantic similarity: N/A (no embeddings)"
           end
           report << ""
-          report << "  **Suggestion:** Review both entries and consider merging with MemoryMultiEdit"
+          report << "  **Suggestion:** Review both entries and consider merging with MemoryEdit"
           report << ""
         end
 

data/lib/swarm_memory/prompts/memory_researcher.md.erb

@@ -28,7 +28,6 @@ You have persistent memory that learns from conversations and helps you answer q
 - `MemoryGlob` - Browse memory by path pattern
 - `MemoryWrite` - Create new memory
 - `MemoryEdit` - Update existing memory
-- `MemoryMultiEdit` - Update multiple memories at once
 - `MemoryDelete` - Delete a memory
 - `MemoryDefrag` - Optimize memory storage
 - `LoadSkill` - Load a skill and swap tools

data/lib/swarm_memory/tools/load_skill.rb

@@ -148,7 +148,6 @@ module SwarmMemory
           "MemoryWrite",
           "MemoryRead",
           "MemoryEdit",
-          "MemoryMultiEdit",
           "MemoryDelete",
           "MemoryGlob",
           "MemoryGrep",

data/lib/swarm_memory/tools/memory_edit.rb

@@ -162,11 +162,12 @@ module SwarmMemory
         # Get existing entry metadata
         entry = @storage.read_entry(file_path: file_path)
 
-        # Write updated content back (preserving the title)
+        # Write updated content back (preserving the title and metadata)
         @storage.write(
           file_path: file_path,
           content: new_content,
           title: entry.title,
+          metadata: entry.metadata,
         )
 
         # Build success message

data/lib/swarm_memory/tools/memory_read.rb

@@ -35,7 +35,7 @@ module SwarmMemory
         - MemoryRead(file_path: "skill/debugging/api-errors.md") - Read a skill before loading it
 
         **Important:**
-        - Always read entries before editing them with MemoryEdit or MemoryMultiEdit
+        - Always read entries before editing them with MemoryEdit
         - Line numbers in output are for reference only - don't include them when editing
         - Each read is tracked to enforce read-before-edit patterns
       DESC

data/lib/swarm_memory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwarmMemory
-  VERSION = "2.1.3"
+  VERSION = "2.2.3"
 end