claude_memory 0.6.0 → 0.7.1

data/lib/claude_memory/mcp/query_guide.rb

@@ -11,50 +11,69 @@ module ClaudeMemory
       PROMPT_TEXT = <<~GUIDE
         # ClaudeMemory Search Strategy Guide
 
-        ## Tool Selection
+        ## Tool Escalation — Cheap to Expensive
 
-        **memory.recall** — Full-text keyword search (fastest)
+        Start with fast, cheap tools. Escalate only when you need more detail.
+
+        ### Tier 1: Fast Lookup (< 50ms, low tokens)
+
+        **memory.recall** — Full-text keyword search
         - Use for: exact terms, known predicates, specific entity names
         - Example: "PostgreSQL", "authentication", "deployment"
         - Returns: facts with provenance receipts
+        - Cost: ~200-500 tokens per call
+
+        **memory.decisions** / **memory.conventions** / **memory.architecture**
+        - Use for: quick access to known categories
+        - Cost: ~100-300 tokens per call
+
+        ### Tier 2: Broad Search (< 200ms, moderate tokens)
 
         **memory.recall_semantic** — Vector similarity search
         - Use for: conceptual queries, paraphrased questions, "find things like X"
         - Modes: `vector` (embeddings only), `text` (FTS only), `both` (hybrid, recommended)
-        - Example: "how does the app handle user sessions" (no exact keyword match needed)
+        - Example: "how does the app handle user sessions"
         - Returns: facts ranked by similarity score (0.0-1.0)
+        - Cost: ~300-800 tokens per call
 
         **memory.search_concepts** — Multi-concept AND query
         - Use for: intersection of 2-5 concepts that must ALL be present
         - Example: concepts=["authentication", "JWT", "middleware"]
-        - Returns: facts matching all concepts, ranked by average similarity
+        - Cost: ~300-800 tokens per call
 
-        **memory.recall_index** → **memory.recall_details** — Progressive disclosure
-        - Use for: browsing large result sets efficiently
-        - Step 1: `recall_index` returns lightweight previews with token estimates
-        - Step 2: `recall_details` fetches full data for selected fact IDs
-        - Saves tokens when you only need a few facts from many matches
+        **memory.recall_index** — Lightweight previews
+        - Use for: browsing large result sets before committing to full details
+        - Cost: ~100-200 tokens (compact previews)
 
-        ## Shortcut Tools
+        ### Tier 3: Targeted Deep Dive (moderate tokens)
 
-        **memory.decisions** — Architectural decisions and constraints
-        **memory.conventions** — Coding style preferences and rules
-        **memory.architecture** — Framework choices and patterns
+        **memory.recall_details** — Full details for selected fact IDs
+        - Use after: `recall_index` to fetch only the facts you need
+        - Cost: ~200-600 tokens per call
 
-        ## Context-Aware Tools
+        **memory.explain** — Detailed provenance for a specific fact
+        - Use when: you need to know where a fact came from and how confident it is
+        - Cost: ~300-500 tokens per call
+
+        ### Tier 4: Relationship Exploration (higher tokens)
+
+        **memory.fact_graph** — Dependency graph visualization
+        - Use when: you need to understand how facts relate (supersession chains, conflicts)
+        - Cost: ~400-1000 tokens per call
 
         **memory.facts_by_tool** — Facts discovered via specific tool (Read, Edit, Bash)
         **memory.facts_by_context** — Facts from specific git branch or directory
+        - Use when: you need facts from a specific workflow context
+        - Cost: ~300-800 tokens per call
+
+        ## Recommended Workflow
 
-        ## Decision Tree
+        1. **Start broad**: `memory.recall` or shortcut tools (decisions/conventions/architecture)
+        2. **Refine if needed**: `memory.recall_semantic` for fuzzy matches
+        3. **Drill into specifics**: `memory.recall_details` or `memory.explain` for selected facts
+        4. **Explore relationships**: `memory.fact_graph` only when you need lineage/conflicts
 
-        1. Know the exact keyword? → `memory.recall`
-        2. Conceptual/fuzzy question? → `memory.recall_semantic` (mode: both)
-        3. Need intersection of topics? → `memory.search_concepts`
-        4. Looking for decisions? → `memory.decisions`
-        5. Looking for conventions? → `memory.conventions`
-        6. Many results expected? → `memory.recall_index` then `memory.recall_details`
-        7. Need provenance? → `memory.explain` with fact ID
+        Do NOT jump to Tier 3-4 tools first. Tier 1 tools answer most questions.
 
         ## Score Interpretation (semantic search)
 

data/lib/claude_memory/mcp/response_formatter.rb

@@ -233,7 +233,7 @@ module ClaudeMemory
       # @param stats [Hash] Sweeper stats
       # @return [Hash] Formatted sweep response
       def self.format_sweep_stats(scope, stats)
-        {
+        result = {
           scope: scope,
           proposed_expired: stats[:proposed_facts_expired],
           disputed_expired: stats[:disputed_facts_expired],
@@ -241,6 +241,8 @@ module ClaudeMemory
           content_pruned: stats[:old_content_pruned],
           elapsed_seconds: stats[:elapsed_seconds].round(3)
         }
+        result[:escalation_level] = stats[:escalation_level].to_s if stats[:escalation_level]
+        result
       end
 
       # Format semantic search results with similarity scores

data/lib/claude_memory/mcp/server.rb

@@ -4,6 +4,7 @@ require "json"
 require_relative "instructions_builder"
 require_relative "query_guide"
 require_relative "text_summary"
+require_relative "error_classifier"
 
 module ClaudeMemory
   module MCP

data/lib/claude_memory/mcp/text_summary.rb

@@ -104,7 +104,8 @@ module ClaudeMemory
       end
 
       def self.summarize_sweep(result)
-        "Sweep (#{result[:scope]}): #{result[:proposed_expired]} proposed expired, " \
+        escalation = result[:escalation_level] ? " [#{result[:escalation_level]}]" : ""
+        "Sweep (#{result[:scope]})#{escalation}: #{result[:proposed_expired]} proposed expired, " \
           "#{result[:disputed_expired]} disputed expired, " \
           "#{result[:orphaned_deleted]} orphaned deleted, " \
           "#{result[:content_pruned]} content pruned " \

data/lib/claude_memory/mcp/tool_definitions.rb

@@ -5,6 +5,15 @@ module ClaudeMemory
     # MCP tool definitions for Claude Memory
     # Pure data structure - no logic, just tool schemas
     module ToolDefinitions
+      # Annotations for read-only query tools (safe to call anytime)
+      READ_ONLY = {readOnlyHint: true, idempotentHint: true, destructiveHint: false}.freeze
+
+      # Annotations for state-changing but non-destructive tools
+      WRITE = {readOnlyHint: false, idempotentHint: false, destructiveHint: false}.freeze
+
+      # Annotations for idempotent writes (safe to retry)
+      WRITE_IDEMPOTENT = {readOnlyHint: false, idempotentHint: true, destructiveHint: false}.freeze
+
       # Returns array of tool definitions for MCP protocol
       # @return [Array<Hash>] Tool definitions with name, description, and inputSchema
       def self.all
@@ -21,7 +30,8 @@ module ClaudeMemory
                 compact: {type: "boolean", description: "Omit provenance receipts for ~60% smaller responses (~800 → ~300 tokens/result)", default: false}
               },
               required: ["query"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.recall_index",
@@ -34,7 +44,8 @@ module ClaudeMemory
                 scope: {type: "string", enum: ["all", "global", "project"], description: "Scope: 'all' (both), 'global' (user-wide), 'project' (current only)", default: "all"}
               },
               required: ["query"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.recall_details",
@@ -46,7 +57,8 @@ module ClaudeMemory
                 scope: {type: "string", enum: ["project", "global"], description: "Database to query", default: "project"}
               },
               required: ["fact_ids"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.explain",
@@ -58,7 +70,8 @@ module ClaudeMemory
                 scope: {type: "string", enum: ["global", "project"], description: "Which database to look in", default: "project"}
               },
               required: ["fact_id"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.changes",
@@ -70,7 +83,8 @@ module ClaudeMemory
                 limit: {type: "integer", default: 20},
                 scope: {type: "string", enum: ["all", "global", "project"], default: "all"}
               }
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.conflicts",
@@ -80,18 +94,21 @@ module ClaudeMemory
               properties: {
                 scope: {type: "string", enum: ["all", "global", "project"], default: "all"}
               }
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.sweep_now",
-            description: "Run maintenance sweep on a database",
+            description: "Run maintenance sweep on a database. Use escalate: true for guaranteed progress (normal → aggressive → fallback).",
             inputSchema: {
               type: "object",
               properties: {
                 budget_seconds: {type: "integer", default: 5},
-                scope: {type: "string", enum: ["global", "project"], default: "project"}
+                scope: {type: "string", enum: ["global", "project"], default: "project"},
+                escalate: {type: "boolean", default: false, description: "Enable three-level escalation (normal → aggressive → fallback) to guarantee progress"}
               }
-            }
+            },
+            annotations: WRITE
           },
           {
             name: "memory.status",
@@ -99,7 +116,8 @@ module ClaudeMemory
             inputSchema: {
               type: "object",
               properties: {}
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.stats",
@@ -109,7 +127,8 @@ module ClaudeMemory
               properties: {
                 scope: {type: "string", enum: ["all", "global", "project"], description: "Show stats for: all (default), global, or project", default: "all"}
               }
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.promote",
@@ -120,7 +139,8 @@ module ClaudeMemory
                 fact_id: {type: "integer", description: "Project fact ID to promote to global"}
               },
               required: ["fact_id"]
-            }
+            },
+            annotations: WRITE_IDEMPOTENT
           },
           {
             name: "memory.store_extraction",
@@ -174,7 +194,8 @@ module ClaudeMemory
                 scope: {type: "string", enum: ["global", "project"], description: "Default scope for facts", default: "project"}
               },
               required: ["facts"]
-            }
+            },
+            annotations: WRITE
           },
           {
             name: "memory.decisions",
@@ -184,7 +205,8 @@ module ClaudeMemory
               properties: {
                 limit: {type: "integer", default: 10, description: "Maximum results to return"}
               }
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.conventions",
@@ -194,7 +216,8 @@ module ClaudeMemory
               properties: {
                 limit: {type: "integer", default: 20, description: "Maximum results to return"}
               }
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.architecture",
@@ -204,7 +227,8 @@ module ClaudeMemory
               properties: {
                 limit: {type: "integer", default: 10, description: "Maximum results to return"}
               }
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.facts_by_tool",
@@ -217,7 +241,8 @@ module ClaudeMemory
                 scope: {type: "string", enum: ["all", "global", "project"], default: "all", description: "Filter by scope"}
               },
               required: ["tool_name"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.facts_by_context",
@@ -230,7 +255,8 @@ module ClaudeMemory
                 limit: {type: "integer", default: 20, description: "Maximum results to return"},
                 scope: {type: "string", enum: ["all", "global", "project"], default: "all", description: "Filter by scope"}
               }
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.recall_semantic",
@@ -245,7 +271,8 @@ module ClaudeMemory
                 compact: {type: "boolean", description: "Omit provenance receipts for ~60% smaller responses (~800 → ~300 tokens/result)", default: false}
               },
               required: ["query"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.search_concepts",
@@ -265,7 +292,8 @@ module ClaudeMemory
                 compact: {type: "boolean", description: "Omit provenance receipts for ~60% smaller responses (~800 → ~300 tokens/result)", default: false}
               },
               required: ["concepts"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.fact_graph",
@@ -278,7 +306,8 @@ module ClaudeMemory
                 scope: {type: "string", enum: ["global", "project"], description: "Which database to search", default: "project"}
               },
               required: ["fact_id"]
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.check_setup",
@@ -286,7 +315,8 @@ module ClaudeMemory
             inputSchema: {
               type: "object",
               properties: {}
-            }
+            },
+            annotations: READ_ONLY
           },
           {
             name: "memory.list_projects",
@@ -294,7 +324,8 @@ module ClaudeMemory
             inputSchema: {
               type: "object",
               properties: {}
-            }
+            },
+            annotations: READ_ONLY
           }
         ]
       end

data/lib/claude_memory/mcp/tools.rb

@@ -6,6 +6,7 @@ require_relative "tool_helpers"
 require_relative "response_formatter"
 require_relative "tool_definitions"
 require_relative "setup_status_analyzer"
+require_relative "error_classifier"
 
 module ClaudeMemory
   module MCP
@@ -79,7 +80,7 @@ module ClaudeMemory
 
       def recall(args)
         # Check if databases exist before querying
-        return database_not_found_error(StandardError.new("Database not initialized")) unless databases_exist?
+        return database_not_found_error unless databases_exist?
 
         scope = extract_scope(args)
         limit = extract_limit(args)
@@ -87,8 +88,8 @@ module ClaudeMemory
         query = args["query"]
         results = @recall.query(query, limit: limit, scope: scope, include_raw_text: !compact)
         ResponseFormatter.format_recall_results(results, compact: compact, query: query)
-      rescue Sequel::DatabaseError, Sequel::DatabaseConnectionError, SQLite3::CantOpenException, Errno::ENOENT => e
-        database_not_found_error(e)
+      rescue Sequel::DatabaseError, Sequel::DatabaseConnectionError, Errno::ENOENT => e
+        classified_error(e, tool_name: "memory.recall")
       end
 
       def recall_index(args)
@@ -143,7 +144,12 @@ module ClaudeMemory
         return {error: "Database not available"} unless store
 
         sweeper = Sweep::Sweeper.new(store)
-        stats = sweeper.run!(budget_seconds: args["budget_seconds"] || 5)
+        budget = args["budget_seconds"] || 5
+        stats = if args["escalate"]
+          sweeper.run_with_escalation!(budget_seconds: budget)
+        else
+          sweeper.run!(budget_seconds: budget)
+        end
         ResponseFormatter.format_sweep_stats(scope, stats)
       end
 
@@ -399,17 +405,16 @@ module ClaudeMemory
         end
       end
 
-      def database_not_found_error(error)
-        {
-          error: "Database not found or not accessible",
-          message: "ClaudeMemory may not be initialized. Run memory.check_setup for detailed status.",
-          details: error.message,
-          recommendations: [
-            "Run memory.check_setup to diagnose the issue",
-            "If not initialized, run: claude-memory init",
-            "For help: claude-memory doctor"
-          ]
-        }
+      def database_not_found_error(error = nil)
+        if error
+          ErrorClassifier.build_error_response(error, tool_name: "recall")
+        else
+          ErrorClassifier.build_benign_response(:not_initialized, tool_name: "recall")
+        end
+      end
+
+      def classified_error(error, tool_name: nil)
+        ErrorClassifier.build_error_response(error, tool_name: tool_name)
       end
 
       def check_setup
@@ -604,7 +609,7 @@ module ClaudeMemory
               entry[:facts_total] = temp_store.facts.count
               entry[:entities] = temp_store.entities.count
               temp_store.close
-            rescue => _e
+            rescue Sequel::DatabaseError, Extralite::Error, IOError => _e
               entry[:error] = "Could not read database"
             end
           end
@@ -627,9 +632,21 @@ module ClaudeMemory
         stats[:vec_available] = vec_index.available?
         stats[:vec_indexed] = vec_index.coverage_stats[:vec_indexed] if vec_index.available?
 
+        if fts_legacy?(store)
+          stats[:fts_legacy] = true
+          stats[:optimization_hint] = "Run 'claude-memory compact' to reduce database size by ~40%"
+        end
+
         stats
       end
 
+      def fts_legacy?(store)
+        row = store.db.fetch("SELECT sql FROM sqlite_master WHERE name = 'content_fts' AND type = 'table'").first
+        row && !row[:sql].to_s.include?("content=''")
+      rescue
+        false
+      end
+
       def detailed_stats(store)
         active_facts = store.facts.where(status: "active").count
 

data/lib/claude_memory/recall.rb

@@ -561,13 +561,15 @@ module ClaudeMemory
       facts_data = store.facts_with_embeddings(limit: 5000)
       return [] if facts_data.empty?
 
-      # Parse embeddings and prepare candidates
-      candidates = Core::EmbeddingCandidateBuilder.build_candidates(facts_data)
+      # Deduplicate: group facts by embedding, score unique embeddings only, fan out
+      unique_candidates, fact_groups = dedup_candidates(facts_data)
+      return [] if unique_candidates.empty?
 
-      return [] if candidates.empty?
+      # Calculate similarities on unique embeddings only
+      top_unique = Embeddings::Similarity.top_k(query_embedding, unique_candidates, limit)
 
-      # Calculate similarities and rank
-      top_matches = Embeddings::Similarity.top_k(query_embedding, candidates, limit)
+      # Fan out: expand unique matches back to all fact_ids sharing that embedding
+      top_matches = fan_out_matches(top_unique, fact_groups, limit)
 
       # Batch fetch full fact details
       fact_ids = top_matches.map { |m| m[:candidate][:fact_id] }
@@ -583,6 +585,50 @@ module ClaudeMemory
       )
     end
 
+    # Group facts by embedding_json, return unique candidates + mapping
+    def dedup_candidates(facts_data)
+      groups = {}   # embedding_json → [fact_ids]
+      unique = {}   # embedding_json → parsed candidate (first occurrence)
+
+      facts_data.each do |row|
+        key = row[:embedding_json]
+        if unique.key?(key)
+          groups[key] << row[:id]
+        else
+          candidate = Core::EmbeddingCandidateBuilder.parse_candidate(row)
+          next unless candidate
+          unique[key] = candidate
+          groups[key] = [row[:id]]
+        end
+      end
+
+      [unique.values, groups]
+    end
+
+    # Expand unique matches back to all fact_ids sharing the same embedding
+    def fan_out_matches(top_unique, fact_groups, limit)
+      results = []
+      top_unique.each do |match|
+        candidate = match[:candidate]
+        similarity = match[:similarity]
+
+        # Find the group key for this candidate's embedding
+        group_key = fact_groups.find { |_key, ids| ids.include?(candidate[:fact_id]) }&.first
+        next unless group_key
+
+        fact_groups[group_key].each do |fact_id|
+          results << {
+            candidate: candidate.merge(fact_id: fact_id),
+            similarity: similarity
+          }
+          break if results.size >= limit
+        end
+        break if results.size >= limit
+      end
+
+      results
+    end
+
     def search_by_fts(store, query_text, limit, source)
       fts = Index::LexicalFTS.new(store)
       ranked_results = fts.search_with_ranks(query_text, limit: limit * 2)

data/lib/claude_memory/resolve/resolver.rb

@@ -9,8 +9,6 @@ module ClaudeMemory
 
       def apply(extraction, content_item_id: nil, occurred_at: nil, project_path: nil, scope: "project")
         occurred_at ||= Time.now.utc.iso8601
-        @current_project_path = project_path
-        @current_scope = scope
 
         result = {
           entities_created: 0,
@@ -27,7 +25,8 @@ module ClaudeMemory
           result[:entities_created] = entity_ids.size
 
           extraction.facts.each do |fact_data|
-            outcome = resolve_fact(fact_data, entity_ids, content_item_id, occurred_at)
+            outcome = resolve_fact(fact_data, entity_ids, content_item_id, occurred_at,
+              project_path: project_path, scope: scope)
             result[:facts_created] += outcome[:created]
             result[:facts_superseded] += outcome[:superseded]
             result[:conflicts_created] += outcome[:conflicts]
@@ -49,12 +48,13 @@ module ClaudeMemory
         entity_ids
       end
 
-      def resolve_fact(fact_data, entity_ids, content_item_id, occurred_at)
+      def resolve_fact(fact_data, entity_ids, content_item_id, occurred_at, project_path:, scope:)
         subject_id = resolve_subject(fact_data, entity_ids)
         existing_facts = @store.facts_for_slot(subject_id, fact_data[:predicate])
         resolution = determine_resolution(existing_facts, fact_data, entity_ids)
 
-        apply_resolution(resolution, fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts)
+        apply_resolution(resolution, fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts,
+          project_path: project_path, scope: scope)
       end
 
       def resolve_subject(fact_data, entity_ids)
@@ -77,14 +77,16 @@ module ClaudeMemory
         end
       end
 
-      def apply_resolution(resolution, fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts)
+      def apply_resolution(resolution, fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts, project_path:, scope:)
         case resolution
         when :reinforce
           apply_reinforcement(existing_facts, fact_data, entity_ids, content_item_id)
         when :conflict
-          apply_conflict(existing_facts, fact_data, subject_id, content_item_id, occurred_at)
+          apply_conflict(existing_facts, fact_data, subject_id, content_item_id, occurred_at,
+            project_path: project_path, scope: scope)
         else
-          apply_insert(fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts, resolution)
+          apply_insert(fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts, resolution,
+            project_path: project_path, scope: scope)
         end
       end
 
@@ -95,28 +97,30 @@ module ClaudeMemory
         {created: 0, superseded: 0, conflicts: 0, provenance: 1}
       end
 
-      def apply_conflict(existing_facts, fact_data, subject_id, content_item_id, occurred_at)
-        create_conflict(existing_facts.first[:id], fact_data, subject_id, content_item_id, occurred_at)
+      def apply_conflict(existing_facts, fact_data, subject_id, content_item_id, occurred_at, project_path:, scope:)
+        create_conflict(existing_facts.first[:id], fact_data, subject_id, content_item_id, occurred_at,
+          project_path: project_path, scope: scope)
         {created: 0, superseded: 0, conflicts: 1, provenance: 0}
       end
 
-      def apply_insert(fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts, resolution)
+      def apply_insert(fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts, resolution, project_path:, scope:)
         superseded_count = 0
         if resolution == :supersede
           supersede_facts(existing_facts, occurred_at)
           superseded_count = existing_facts.size
         end
 
-        fact_id = insert_new_fact(fact_data, subject_id, entity_ids, occurred_at)
+        fact_id = insert_new_fact(fact_data, subject_id, entity_ids, occurred_at,
+          project_path: project_path, scope: scope)
         link_superseded_facts(fact_id, existing_facts) if superseded_count > 0
         add_provenance(fact_id, content_item_id, fact_data)
 
         {created: 1, superseded: superseded_count, conflicts: 0, provenance: 1}
       end
 
-      def insert_new_fact(fact_data, subject_id, entity_ids, occurred_at)
-        fact_scope = fact_data[:scope_hint] || @current_scope
-        fact_project = (fact_scope == "global") ? nil : @current_project_path
+      def insert_new_fact(fact_data, subject_id, entity_ids, occurred_at, project_path:, scope:)
+        fact_scope = fact_data[:scope_hint] || scope
+        fact_project = (fact_scope == "global") ? nil : project_path
 
         @store.insert_fact(
           subject_entity_id: subject_id,
@@ -153,7 +157,7 @@ module ClaudeMemory
         end
       end
 
-      def create_conflict(existing_fact_id, new_fact_data, subject_id, content_item_id, occurred_at)
+      def create_conflict(existing_fact_id, new_fact_data, subject_id, content_item_id, occurred_at, project_path:, scope:)
         # Already within transaction from resolve_fact
         new_fact_id = @store.insert_fact(
           subject_entity_id: subject_id,
@@ -163,8 +167,8 @@ module ClaudeMemory
           confidence: new_fact_data[:confidence] || 1.0,
           status: "disputed",
           valid_from: occurred_at,
-          scope: @current_scope,
-          project_path: @current_project_path
+          scope: scope,
+          project_path: project_path
         )
 
         @store.insert_conflict(