llmemory 0.2.10 → 0.3.0

data/lib/llmemory/consolidation.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "consolidation/unit"
+require_relative "consolidation/policy"
+require_relative "consolidation/rule_based_policy"
+require_relative "consolidation/filter"
+
+module Llmemory
+  module Consolidation
+  end
+end

data/lib/llmemory/instrumentation.rb

@@ -16,10 +16,19 @@ module Llmemory
   #                             output_tokens:, total_tokens:
   #   memory_write.llmemory     memory_type:, user_id:
   #   memory_forget.llmemory    memory_type:, user_id:, count:
-  #   retrieve.llmemory         query_chars:, candidates:, results:
+  #   retrieve.llmemory         query_chars:, candidates:, results:, zero_mem_compliant:
   #   iterative_retrieve.llmemory  hops:, total_results:
   #   reflect.llmemory          window:, insights:
   #   mine_skills.llmemory      window:, auto_register:
+  #   trace_write.llmemory      user_id:, session_id:, trace_id:, sequence:, maintenance_fanout:
+  #   zero_mem_state_update.llmemory  user_id:, state_key:, trace_id:, supersedes_trace_id:
+  #   zero_mem_profile.llmemory       user_id:, query_chars:
+  #   zero_mem_hierarchy_retrieve.llmemory  user_id:, workload:
+  #   zero_mem_retrieve.llmemory      user_id:, evidence_count:, degraded:
+  #   zero_mem_graph_retrieve.llmemory user_id:
+  #   zero_mem_closure.llmemory       user_id:, seeds:
+  #   zero_mem_calibrate.llmemory     user_id:, trace_count:
+  #   encoder_embed.llmemory          user_id:, trace_id:, model:, dimensions:, duration_ms:
   module Instrumentation
     module_function
 

data/lib/llmemory/long_term/file_based/memory.rb

@@ -6,6 +6,7 @@ require_relative "category"
 require_relative "storage"
 require_relative "../../noise_filter"
 require_relative "../../memory_module"
+require_relative "../../consolidation/filter"
 
 module Llmemory
   module LongTerm
@@ -28,19 +29,26 @@ module Llmemory
           resource_id = save_resource(text)
           append_to_daily_log(text) if Llmemory.configuration.daily_logs_enabled && @storage.respond_to?(:save_daily_log_entry)
           items = @extractor.extract_items(text)
-          contents = items.map do |item|
-            item.is_a?(Hash) ? (item["content"] || item[:content]).to_s : item.to_s
-          end
-          classifications = @extractor.classify_items(contents)
+          classifications = @extractor.classify_items(
+            items.map { |item| item.is_a?(Hash) ? (item["content"] || item[:content]).to_s : item.to_s }
+          )
+          items = Consolidation::Filter.apply_items(items, classifications)
           updates_by_category = {}
 
           items.each do |item|
             content = item.is_a?(Hash) ? (item["content"] || item[:content]) : item.to_s
             importance = (item["importance"] || item[:importance] || 0.7).to_f
             cat = classifications[content] || @extractor.classify_item(content)
+            volatile = item[:volatile] == true
             updates_by_category[cat] ||= []
             updates_by_category[cat] << content.to_s
-            save_item(category: cat, item: item, source_resource_id: resource_id, importance: importance)
+            save_item(
+              category: cat,
+              item: item,
+              source_resource_id: resource_id,
+              importance: importance,
+              volatile: volatile
+            )
           end
 
           updates_by_category.each do |category, new_memories|
@@ -70,13 +78,15 @@ module Llmemory
           end
 
           items.first(top_k).each do |i|
+            prov = i[:provenance] || i["provenance"]
             out << {
               id: i[:id] || i["id"],
               text: i[:content] || i["content"],
               timestamp: i[:created_at] || i["created_at"],
               score: 1.0,
               importance: (i[:importance] || i["importance"] || 1.0).to_f,
-              evergreen: i[:evergreen] || i["evergreen"]
+              evergreen: i[:evergreen] || i["evergreen"],
+              volatile: Consolidation::Filter.volatile_marked?(prov)
             }
           end
           resources.first([top_k - out.size, 0].max).each do |r|
@@ -152,11 +162,12 @@ module Llmemory
           @storage.save_resource(@user_id, text)
         end
 
-        def save_item(category:, item:, source_resource_id:, importance: 0.7)
+        def save_item(category:, item:, source_resource_id:, importance: 0.7, volatile: false)
           content = item.is_a?(Hash) ? item["content"] || item[:content] : item.to_s
           provenance = Llmemory::Provenance.from_resource(
             source_resource_id, method: "fact_extraction", confidence: importance
           )
+          provenance = Consolidation::Filter.volatile_provenance(provenance) if volatile
           @storage.save_item(@user_id, category: category, content: content, source_resource_id: source_resource_id, importance: importance, provenance: provenance)
         end
 

data/lib/llmemory/long_term/graph_based/memory.rb

@@ -8,6 +8,7 @@ require_relative "conflict_resolver"
 require_relative "storage"
 require_relative "../../noise_filter"
 require_relative "../../memory_module"
+require_relative "../../consolidation/filter"
 
 module Llmemory
   module LongTerm
@@ -32,6 +33,7 @@ module Llmemory
           return true if text.strip.empty?
 
           entities, relations = extract_graph(text)
+          relations = Consolidation::Filter.apply_relations(relations)
           return true if entities.empty? && relations.empty?
 
           provenance = Llmemory::Provenance.from_text_fingerprint(text, method: "entity_relation_extraction")
@@ -54,7 +56,8 @@ module Llmemory
               text: r[:text],
               timestamp: r[:created_at] || r[:timestamp],
               score: r[:score] || 1.0,
-              importance: r[:importance]
+              importance: r[:importance],
+              volatile: r[:volatile]
             }
           end
         end
@@ -147,8 +150,12 @@ module Llmemory
             object = (r[:object] || r["object"]).to_s.strip
             next if subject.empty? || predicate.empty? || object.empty?
 
-            subject_id = name_to_id[subject] || @kg.add_node(entity_type: "concept", name: subject, properties: { "provenance" => provenance })
-            object_id = name_to_id[object] || @kg.add_node(entity_type: "concept", name: object, properties: { "provenance" => provenance })
+            volatile = r[:volatile] == true
+            relation_provenance = volatile ? Consolidation::Filter.volatile_provenance(provenance) : provenance
+            edge_properties = volatile ? Consolidation::Filter.volatile_properties("provenance" => relation_provenance) : {"provenance" => relation_provenance}
+
+            subject_id = name_to_id[subject] || @kg.add_node(entity_type: "concept", name: subject, properties: { "provenance" => relation_provenance })
+            object_id = name_to_id[object] || @kg.add_node(entity_type: "concept", name: object, properties: { "provenance" => relation_provenance })
 
             existing = @kg.find_edges(
               subject: subject_id,
@@ -164,13 +171,13 @@ module Llmemory
               subject_id: subject_id,
               predicate: predicate,
               target_id: object_id,
-              properties: { "provenance" => provenance },
+              properties: edge_properties,
               created_at: Time.now,
               archived_at: nil
             )
             archived_ids = @conflict_resolver.resolve(edge)
             remove_edge_embeddings(archived_ids)
-            edge_id = @kg.add_edge(subject: subject_id, predicate: predicate, object: object_id, properties: { "provenance" => provenance })
+            edge_id = @kg.add_edge(subject: subject_id, predicate: predicate, object: object_id, properties: edge_properties)
 
             edge_text = "#{subject} #{predicate} #{object}"
             embedding = @vector_store.respond_to?(:embed) ? @vector_store.embed(edge_text) : nil
@@ -197,7 +204,13 @@ module Llmemory
             next unless active_edge?(id)
 
             meta = v[:metadata] || v["metadata"] || {}
-            { id: id, text: meta["text"] || meta[:text] || id.to_s, score: v[:score] || v["score"] || 1.0, created_at: meta["created_at"] || meta[:created_at] }
+            {
+              id: id,
+              text: meta["text"] || meta[:text] || id.to_s,
+              score: v[:score] || v["score"] || 1.0,
+              created_at: meta["created_at"] || meta[:created_at],
+              volatile: volatile_candidate?(edge_properties(id))
+            }
           end
 
           node_ids = out.flat_map { |r| extract_node_ids_from_text(r[:text]) }.compact.uniq
@@ -209,7 +222,7 @@ module Llmemory
               subj = @kg.find_node_by_id(e.subject_id)
               obj = @kg.find_node_by_id(e.target_id)
               edge_text = "#{subj&.name} #{e.predicate} #{obj&.name}"
-              out << { id: e.id, text: edge_text, score: 0.85, created_at: e.created_at } unless out.any? { |o| o[:text] == edge_text }
+              out << { id: e.id, text: edge_text, score: 0.85, created_at: e.created_at, volatile: volatile_candidate?(e.properties) } unless out.any? { |o| o[:text] == edge_text }
             end
           end
 
@@ -222,7 +235,7 @@ module Llmemory
               obj = @kg.find_node_by_id(e.target_id)
               next unless subj && obj
               edge_text = "#{subj.name} #{e.predicate} #{obj.name}"
-              out << { id: e.id, text: edge_text, score: 0.7, created_at: e.created_at }
+              out << { id: e.id, text: edge_text, score: 0.7, created_at: e.created_at, volatile: volatile_candidate?(e.properties) }
             end
           end
 
@@ -278,6 +291,16 @@ module Llmemory
           @kg.find_edges(subject: nil, predicate: nil, object: nil, include_archived: false)
             .any? { |edge| edge.id.to_s == edge_id.to_s }
         end
+
+        def volatile_candidate?(properties_or_provenance)
+          Consolidation::Filter.volatile_marked?(properties_or_provenance)
+        end
+
+        def edge_properties(edge_id)
+          @kg.find_edges(subject: nil, predicate: nil, object: nil, include_archived: false)
+            .find { |edge| edge.id.to_s == edge_id.to_s }
+            &.properties
+        end
       end
     end
   end

data/lib/llmemory/maintenance/cognitive_pass.rb

@@ -43,7 +43,22 @@ module Llmemory
       end
 
       def run!
-        report = { consolidated: nil, insights: [], mined: [], expired: { episodic: 0, procedural: 0 }, errors: {} }
+        report = {
+          consolidated: nil,
+          insights: [],
+          mined: [],
+          expired: { episodic: 0, procedural: 0 },
+          errors: {},
+          disabled: []
+        }
+
+        if @memory&.zero_mem_strict?
+          report[:disabled] = %i[consolidate reflect mine]
+          report[:consolidated] = false
+          step(report, :zero_mem_repair) { report[:zero_mem] = zero_mem_repair } if @memory.trace_store
+          step(report, :expire) { report[:expired] = expire } if @expire
+          return report
+        end
 
         step(report, :consolidate) { report[:consolidated] = consolidate } if @memory
         step(report, :reflect)     { report[:insights] = reflect } if @reflect
@@ -79,6 +94,19 @@ module Llmemory
         TTLExpiry.run!(@user_id, episodic: episodic, procedural: procedural)
       end
 
+      def zero_mem_repair
+        store = @memory.trace_store
+        repair = ZeroMem::Repair.new(storage: store)
+        sessions = store.list_traces(@user_id).map(&:session_id).uniq
+        sessions.map do |sid|
+          repair.run!(
+            user_id: @user_id,
+            session_id: sid,
+            checkpoint_messages: @memory.messages
+          )
+        end
+      end
+
       def episodic
         @episodic ||= @memory&.episodic || Llmemory::LongTerm::Episodic::Memory.new(user_id: @user_id)
       end

data/lib/llmemory/maintenance/policy_prune.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../consolidation/unit"
+require_relative "../consolidation/filter"
+
+module Llmemory
+  module Maintenance
+    # Archives long-term facts that the current consolidation policy would drop.
+    # Useful for cleaning legacy data consolidated before a policy was configured.
+    class PolicyPrune
+      Result = Struct.new(:graph_edges, :file_items, :dry_run, keyword_init: true) do
+        def total
+          graph_edges + file_items
+        end
+
+        def to_h
+          { graph_edges: graph_edges, file_items: file_items, dry_run: dry_run, total: total }
+        end
+      end
+
+      def initialize(dry_run: false, policy: nil)
+        @dry_run = dry_run
+        @policy = policy || Llmemory.configuration.consolidation_policy
+      end
+
+      def run(memory:)
+        case memory
+        when LongTerm::GraphBased::Memory
+          Result.new(graph_edges: prune_graph(memory), file_items: 0, dry_run: @dry_run)
+        when LongTerm::FileBased::Memory
+          Result.new(graph_edges: 0, file_items: prune_file(memory), dry_run: @dry_run)
+        else
+          raise ArgumentError, "Unsupported memory type: #{memory.class}"
+        end
+      end
+
+      private
+
+      def prune_graph(memory)
+        storage = memory.instance_variable_get(:@graph_storage)
+        kg = memory.instance_variable_get(:@kg)
+        user_id = memory.user_id
+        return 0 unless storage.respond_to?(:list_edges)
+
+        removed = 0
+        storage.list_edges(user_id).each do |edge|
+          next if edge.archived?
+
+          subject = kg.find_node_by_id(edge.subject_id)
+          object = kg.find_node_by_id(edge.target_id)
+          unit = Consolidation::Unit.from_relation(
+            subject: subject&.name,
+            predicate: edge.predicate,
+            object: object&.name
+          )
+          next unless @policy.decide(unit) == :drop
+
+          removed += 1
+          next if @dry_run
+
+          memory.forget(ids: [edge.id], reason: "consolidation_policy_prune")
+        end
+        removed
+      end
+
+      def prune_file(memory)
+        storage = memory.instance_variable_get(:@storage)
+        user_id = memory.user_id
+        removed = 0
+
+        storage.get_all_items(user_id).each do |item|
+          unit = Consolidation::Unit.from_item(item, category: item[:category] || item["category"])
+          next unless @policy.decide(unit) == :drop
+
+          item_id = item[:id] || item["id"]
+          removed += 1
+          next if @dry_run
+
+          memory.forget(ids: [item_id], reason: "consolidation_policy_prune")
+        end
+        removed
+      end
+    end
+  end
+end

data/lib/llmemory/maintenance/zero_mem_ttl.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module Maintenance
+    class ZeroMemTTL
+      def initialize(storage:, ttl_days: nil)
+        @storage = storage
+        @ttl_days = ttl_days || Llmemory.configuration.zero_mem_ttl_days
+      end
+
+      def run!(user_id:, dry_run: false)
+        return { archived: 0, skipped: true } if @ttl_days.nil? || @ttl_days.to_i <= 0
+
+        cutoff = Time.now - (@ttl_days.to_i * 86_400)
+        archived = 0
+        @storage.list_traces(user_id, include_archived: false).each do |trace|
+          next unless trace.occurred_at < cutoff
+
+          archived += 1
+          @storage.archive_trace(user_id, trace.id) unless dry_run
+        end
+        { archived: archived, dry_run: dry_run, cutoff: cutoff.utc.iso8601 }
+      end
+    end
+  end
+end

data/lib/llmemory/maintenance.rb

@@ -4,6 +4,8 @@ require_relative "maintenance/runner"
 require_relative "maintenance/ttl_expiry"
 require_relative "maintenance/cognitive_pass"
 require_relative "maintenance/search_tokens_backfill"
+require_relative "maintenance/policy_prune"
+require_relative "maintenance/zero_mem_ttl"
 
 module Llmemory
   module Maintenance

data/lib/llmemory/mcp/server.rb

@@ -5,6 +5,7 @@ require_relative "authentication"
 require_relative "tools/memory_search"
 require_relative "tools/memory_save"
 require_relative "tools/memory_retrieve"
+require_relative "tools/memory_retrieve_evidence"
 require_relative "tools/memory_timeline"
 require_relative "tools/memory_add_message"
 require_relative "tools/memory_consolidate"
@@ -175,6 +176,7 @@ module Llmemory
           Tools::MemorySearch,
           Tools::MemorySave,
           Tools::MemoryRetrieve,
+          Tools::MemoryRetrieveEvidence,
           Tools::MemoryTimeline,
           Tools::MemoryTimelineContext,
           Tools::MemoryAddMessage,

data/lib/llmemory/mcp/store_helpers.rb

@@ -30,6 +30,22 @@ module Llmemory
       def graph_based?
         Llmemory.configuration.long_term_type.to_sym == :graph_based
       end
+
+      def trace_store_instance
+        @trace_store_instance ||= ZeroMem::Storages.build
+      end
+
+      def build_memory(user_id:, session_id: "default", trace_store: nil, memory_mode: nil)
+        mode = memory_mode || Llmemory.configuration.memory_mode
+        store = trace_store
+        store = trace_store_instance if store.nil? && ZeroMem::Mode.zero_mem_enabled?(mode)
+        Llmemory::Memory.new(
+          user_id: user_id,
+          session_id: session_id,
+          trace_store: store,
+          memory_mode: mode
+        )
+      end
     end
   end
 end

data/lib/llmemory/mcp/tools/memory_add_message.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../store_helpers"
+
 module Llmemory
   module MCP
     module Tools
@@ -11,17 +13,28 @@ module Llmemory
             user_id: { type: "string", description: "User identifier" },
             session_id: { type: "string", description: "Session identifier (default: 'default')" },
             role: { type: "string", enum: ["user", "assistant", "system", "tool", "tool_result"], description: "Message role" },
-            content: { type: "string", description: "Message content" }
+            content: { type: "string", description: "Message content" },
+            occurred_at: { type: "string", description: "Optional ISO8601 timestamp for trace ingestion" },
+            boundary_id: { type: "string", description: "Optional boundary identifier (Zero-Mem)" },
+            idempotency_key: { type: "string", description: "Optional idempotency key for trace writes" }
           },
           required: ["user_id", "role", "content"]
         )
 
         class << self
-          def call(user_id:, role:, content:, session_id: nil, server_context: nil)
+          def call(user_id:, role:, content:, session_id: nil, occurred_at: nil, boundary_id: nil,
+                   idempotency_key: nil, server_context: nil)
             session = session_id || "default"
 
-            memory = Llmemory::Memory.new(user_id: user_id, session_id: session)
-            memory.add_message(role: role.to_sym, content: content)
+            memory = StoreHelpers.build_memory(user_id: user_id, session_id: session)
+            parsed_time = occurred_at ? Time.parse(occurred_at.to_s) : nil
+            memory.add_message(
+              role: role.to_sym,
+              content: content,
+              occurred_at: parsed_time,
+              boundary_id: boundary_id,
+              idempotency_key: idempotency_key
+            )
 
             ::MCP::Tool::Response.new([{
               type: "text",

data/lib/llmemory/mcp/tools/memory_consolidate.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../store_helpers"
+
 module Llmemory
   module MCP
     module Tools
@@ -20,7 +22,7 @@ module Llmemory
             session = session_id || "default"
             should_clear = clear_session || false
 
-            memory = Llmemory::Memory.new(user_id: user_id, session_id: session)
+            memory = StoreHelpers.build_memory(user_id: user_id, session_id: session)
 
             messages = memory.messages
             if messages.empty?
@@ -33,9 +35,7 @@ module Llmemory
             message_count = messages.size
             memory.consolidate!
 
-            if should_clear
-              memory.clear_session!
-            end
+            memory.clear_session! if should_clear
 
             response_text = "Consolidated #{message_count} messages from session '#{session}' into long-term memory."
             response_text += "\nSession cleared." if should_clear
@@ -44,6 +44,11 @@ module Llmemory
               type: "text",
               text: response_text
             }])
+          rescue Llmemory::GenerativeOperationDisabled => e
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: e.message
+            }], error: true)
           rescue => e
             ::MCP::Tool::Response.new([{
               type: "text",

data/lib/llmemory/mcp/tools/memory_maintain.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../store_helpers"
+
 module Llmemory
   module MCP
     module Tools
@@ -26,7 +28,8 @@ module Llmemory
             opts[:reflection_window] = reflection_window.to_i unless reflection_window.nil?
             opts[:mining_window] = mining_window.to_i unless mining_window.nil?
 
-            report = Llmemory::Maintenance::CognitivePass.run!(user_id, **opts)
+            memory = StoreHelpers.build_memory(user_id: user_id)
+            report = Llmemory::Maintenance::CognitivePass.run!(user_id, memory: memory, **opts)
             ::MCP::Tool::Response.new([{ type: "text", text: format_report(user_id, report) }])
           rescue => e
             ::MCP::Tool::Response.new([{ type: "text", text: "Error running maintenance pass: #{e.message}" }], error: true)
@@ -42,6 +45,8 @@ module Llmemory
               "  skills mined: #{Array(report[:mined]).size}",
               "  expired: episodic=#{expired[:episodic] || 0} procedural=#{expired[:procedural] || 0}"
             ]
+            disabled = Array(report[:disabled])
+            lines << "  disabled: #{disabled.join(', ')}" if disabled.any?
             errors = report[:errors] || {}
             lines << "  errors: #{errors.map { |k, v| "#{k}: #{v}" }.join('; ')}" unless errors.empty?
             lines.join("\n")

data/lib/llmemory/mcp/tools/memory_retrieve.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../store_helpers"
+
 module Llmemory
   module MCP
     module Tools
@@ -25,7 +27,7 @@ module Llmemory
             include_timeline = include_timeline_context == true
             window = timeline_window || 3
 
-            memory = Llmemory::Memory.new(user_id: user_id, session_id: session)
+            memory = StoreHelpers.build_memory(user_id: user_id, session_id: session)
             context = memory.retrieve(query, max_tokens: tokens)
 
             # Add timeline context if requested

data/lib/llmemory/mcp/tools/memory_retrieve_evidence.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../store_helpers"
+
+module Llmemory
+  module MCP
+    module Tools
+      class MemoryRetrieveEvidence < ::MCP::Tool
+        description "Retrieve structured Zero-Mem evidence (traces) for a query without generative LLM calls. Returns JSON plus a text context block."
+
+        input_schema(
+          properties: {
+            query: { type: "string", description: "Evidence query" },
+            user_id: { type: "string", description: "User identifier" },
+            session_id: { type: "string", description: "Session identifier (default: 'default')" },
+            top_k: { type: "integer", description: "Maximum seed traces (default from config)" },
+            max_tokens: { type: "integer", description: "Token budget for assembled evidence" },
+            boundary: { type: "object", description: "Optional session/boundary filter" },
+            explain: { type: "boolean", description: "Include routing/fusion explain payload (default false)" }
+          },
+          required: ["query", "user_id"]
+        )
+
+        class << self
+          def call(query:, user_id:, session_id: nil, top_k: nil, max_tokens: nil, boundary: nil,
+                   explain: false, server_context: nil)
+            unless ZeroMem::Mode.zero_mem_enabled?(Llmemory.configuration.memory_mode)
+              return error_response("memory_retrieve_evidence requires memory_mode :zero_mem or :hybrid")
+            end
+
+            session = session_id || "default"
+            memory = StoreHelpers.build_memory(user_id: user_id, session_id: session)
+            result = memory.retrieve_evidence(
+              query,
+              top_k: top_k,
+              max_tokens: max_tokens,
+              boundary: boundary,
+              explain: explain == true
+            )
+
+            payload = {
+              route: result.route,
+              profile: result.profile.to_h,
+              evidence: result.evidence.map(&:to_h),
+              seed_evidence: result.seed_evidence.map(&:to_h),
+              closure_evidence: result.closure_evidence.map(&:to_h),
+              metrics: result.metrics,
+              degraded: result.degraded,
+              warnings: result.warnings,
+              explain: result.explain,
+              context: result.to_context
+            }
+
+            ::MCP::Tool::Response.new([{
+              type: "text",
+              text: JSON.pretty_generate(payload)
+            }])
+          rescue => e
+            error_response(e.message)
+          end
+
+          def error_response(message)
+            ::MCP::Tool::Response.new([{ type: "text", text: "Error retrieving evidence: #{message}" }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/mcp/tools/memory_stats.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../store_helpers"
+
 module Llmemory
   module MCP
     module Tools
@@ -53,6 +55,16 @@ module Llmemory
             end
 
             stats[:llm_usage] = Llmemory::LLM::UsageLedger.new(store: store).totals(user_id)
+            stats[:memory_mode] = Llmemory.configuration.memory_mode
+            if ZeroMem::Mode.zero_mem_enabled?(Llmemory.configuration.memory_mode)
+              memory = StoreHelpers.build_memory(user_id: user_id)
+              stats[:zero_mem] = memory.zero_mem_status
+              invoke_calls = stats[:llm_usage].dig(:invoke, :calls).to_i
+              stats[:zero_mem_compliant] = ZeroMem::Mode.zero_mem_strict?(Llmemory.configuration.memory_mode) &&
+                                           invoke_calls.zero?
+            else
+              stats[:zero_mem_compliant] = false
+            end
 
             ::MCP::Tool::Response.new([{
               type: "text",
@@ -106,6 +118,16 @@ module Llmemory
 
             output << ""
             output << Llmemory::LLM::UsageLedger.format_text(stats[:llm_usage] || default_llm_usage)
+            output << ""
+            output << "MEMORY MODE: #{stats[:memory_mode]}"
+            if stats[:zero_mem]
+              zm = stats[:zero_mem]
+              output << "ZERO-MEM:"
+              output << "  traces: #{zm[:trace_count]}"
+              output << "  index_lag: #{zm[:index_lag]}"
+              output << "  index_version: #{zm[:index_version]}"
+            end
+            output << "  zero_mem_compliant: #{stats[:zero_mem_compliant]}"
 
             output.join("\n")
           end