llmemory 0.2.1 → 0.2.3

data/lib/llmemory/maintenance/ttl_expiry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module Maintenance
+    # TTL expiry job: soft-archives episodic/procedural entries whose age
+    # exceeds the configured per-type TTL. Designed to run as a maintenance
+    # task (cron / Rails Job). Idempotent — already-archived entries are
+    # skipped by the storage layer.
+    #
+    # Reads `Llmemory.configuration.ttl_episodic_days` and
+    # `Llmemory.configuration.ttl_procedural_days`. A nil/zero TTL disables
+    # expiry for that memory type.
+    #
+    # Returns a hash `{ episodic: N, procedural: M }` with the number of
+    # entries archived per type for the given user.
+    class TTLExpiry
+      DEFAULT_REASON = "ttl_expired"
+
+      def self.run!(user_id, episodic: nil, procedural: nil, reason: DEFAULT_REASON)
+        new(user_id, episodic: episodic, procedural: procedural, reason: reason).run!
+      end
+
+      def initialize(user_id, episodic: nil, procedural: nil, reason: DEFAULT_REASON)
+        @user_id = user_id
+        @episodic = episodic
+        @procedural = procedural
+        @reason = reason
+      end
+
+      def run!
+        {
+          episodic: expire(memory: @episodic ||= Llmemory::LongTerm::Episodic::Memory.new(user_id: @user_id),
+                           ttl_days: Llmemory.configuration.ttl_episodic_days),
+          procedural: expire(memory: @procedural ||= Llmemory::LongTerm::Procedural::Memory.new(user_id: @user_id),
+                             ttl_days: Llmemory.configuration.ttl_procedural_days)
+        }
+      end
+
+      private
+
+      def expire(memory:, ttl_days:)
+        return 0 unless ttl_days && ttl_days.to_f.positive?
+        cutoff = Time.now - (ttl_days.to_f * 86400)
+        ids = memory.expired_ids(cutoff: cutoff)
+        return 0 if ids.empty?
+        memory.forget(ids: ids, reason: @reason, mode: :soft)
+      end
+    end
+  end
+end

data/lib/llmemory/maintenance.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "maintenance/runner"
+require_relative "maintenance/ttl_expiry"
+require_relative "maintenance/cognitive_pass"
 
 module Llmemory
   module Maintenance

data/lib/llmemory/mcp/server.rb

@@ -17,6 +17,8 @@ require_relative "tools/memory_skill_register"
 require_relative "tools/memory_skill_report"
 require_relative "tools/memory_skills"
 require_relative "tools/memory_forget"
+require_relative "tools/memory_mine_skills"
+require_relative "tools/memory_maintain"
 
 module Llmemory
   module MCP
@@ -169,7 +171,9 @@ module Llmemory
           Tools::MemorySkillRegister,
           Tools::MemorySkillReport,
           Tools::MemorySkills,
-          Tools::MemoryForget
+          Tools::MemoryForget,
+          Tools::MemoryMineSkills,
+          Tools::MemoryMaintain
         ]
       end
 

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module MCP
+    module Tools
+      class MemoryMaintain < ::MCP::Tool
+        description "Run the cognitive maintenance pass for a user: reflect (episodes -> insights), mine skills (episodes -> procedural), and expire entries past their TTL. Each step is isolated; a failure in one is reported and does not abort the others. Returns a summary report."
+
+        input_schema(
+          properties: {
+            user_id: { type: "string", description: "User identifier" },
+            reflect: { type: "boolean", description: "Distill insights from recent episodes (default true)" },
+            mine_skills: { type: "boolean", description: "Mine reusable skills from episodes and register them (default: config.skill_mining_enabled)" },
+            expire: { type: "boolean", description: "Soft-archive entries past their TTL (default true)" },
+            reflection_window: { type: "integer", description: "Episodes to reflect over (default 10)" },
+            mining_window: { type: "integer", description: "Episodes to mine for skills (default 20)" }
+          },
+          required: ["user_id"]
+        )
+
+        class << self
+          def call(user_id:, reflect: true, mine_skills: nil, expire: true,
+                   reflection_window: nil, mining_window: nil, server_context: nil)
+            opts = { reflect: reflect, expire: expire }
+            opts[:mine_skills] = mine_skills unless mine_skills.nil?
+            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)
+            ::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)
+          end
+
+          private
+
+          def format_report(user_id, report)
+            expired = report[:expired] || {}
+            lines = [
+              "Cognitive pass for #{user_id}:",
+              "  insights: #{Array(report[:insights]).size}",
+              "  skills mined: #{Array(report[:mined]).size}",
+              "  expired: episodic=#{expired[:episodic] || 0} procedural=#{expired[:procedural] || 0}"
+            ]
+            errors = report[:errors] || {}
+            lines << "  errors: #{errors.map { |k, v| "#{k}: #{v}" }.join('; ')}" unless errors.empty?
+            lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module MCP
+    module Tools
+      class MemoryMineSkills < ::MCP::Tool
+        description "Mine reusable skills from a user's successful episode trajectories (procedural learning). Human-in-the-loop by default: returns skill *proposals* and writes nothing. Set auto_register=true to register them in procedural memory (with provenance back to the source episodes)."
+
+        input_schema(
+          properties: {
+            user_id: { type: "string", description: "User identifier" },
+            window: { type: "integer", description: "Episodes to mine (default 20)" },
+            outcomes: { type: "array", items: { type: "string" }, description: "Optional allowlist of outcome labels to pre-filter episodes (e.g. ['success'])" },
+            auto_register: { type: "boolean", description: "Register the proposals instead of only returning them (default false)" }
+          },
+          required: ["user_id"]
+        )
+
+        class << self
+          def call(user_id:, window: nil, outcomes: nil, auto_register: false, server_context: nil)
+            episodic = Llmemory::LongTerm::Episodic::Memory.new(user_id: user_id)
+            procedural = Llmemory::LongTerm::Procedural::Memory.new(user_id: user_id)
+            result = Llmemory::SkillMining::Miner.new(episodic: episodic, procedural: procedural).mine(
+              window: (window || Llmemory::SkillMining::Miner::DEFAULT_WINDOW).to_i,
+              outcomes: outcomes,
+              auto_register: auto_register
+            )
+
+            ::MCP::Tool::Response.new([{ type: "text", text: format_result(user_id, result, auto_register) }])
+          rescue => e
+            ::MCP::Tool::Response.new([{ type: "text", text: "Error mining skills: #{e.message}" }], error: true)
+          end
+
+          private
+
+          def format_result(user_id, result, auto_register)
+            return "No skills could be mined for user #{user_id}." if result.empty?
+
+            if auto_register
+              "Registered #{result.size} mined skill(s): #{result.join(', ')}"
+            else
+              lines = ["#{result.size} skill proposal(s) for user #{user_id} (not registered):"]
+              result.each do |p|
+                lines << "  - #{p[:name]} (#{p[:kind]}, confidence: #{p[:confidence]}): #{p[:description] || p[:body]}"
+              end
+              lines.join("\n")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/memory.rb

@@ -10,34 +10,57 @@ module Llmemory
     DEFAULT_SESSION_ID = "default"
     STATE_KEY_MESSAGES = :messages
 
-    def initialize(user_id:, session_id: DEFAULT_SESSION_ID, checkpoint: nil, long_term: nil, long_term_type: nil, retrieval_engine: nil, working_memory: nil, episodic: nil, procedural: nil, api_key: nil)
+    def initialize(user_id:, session_id: DEFAULT_SESSION_ID, checkpoint: nil, long_term: nil, long_term_type: nil, retrieval_engine: nil, working_memory: nil, episodic: nil, procedural: nil, api_key: nil, encryption_key: :inherit)
       @user_id = user_id
       @session_id = session_id
-      @checkpoint = checkpoint || ShortTerm::Checkpoint.new(user_id: user_id, session_id: session_id)
+      resolved_key = encryption_key == :inherit ? nil : encryption_key
+      @cipher = Llmemory.build_cipher(resolved_key)
+      @checkpoint = checkpoint || ShortTerm::Checkpoint.new(
+        user_id: user_id,
+        session_id: session_id,
+        cipher: @cipher
+      )
       @working_memory = working_memory
       @episodic = episodic
       @procedural = procedural
       @llm = api_key.to_s.empty? ? nil : Llmemory::LLM.client(api_key: api_key)
       type = long_term_type || Llmemory.configuration.long_term_type || :file_based
       @long_term = long_term || build_long_term(type)
-      @retrieval_engine = retrieval_engine || Retrieval::Engine.new(@long_term, llm: @llm)
+      short_term_store = build_short_term_store(@cipher)
+      @retrieval_engine = retrieval_engine || Retrieval::Engine.new(
+        @long_term,
+        llm: @llm,
+        feedback: Retrieval::FeedbackStore.new(store: short_term_store)
+      )
     end
 
     # Structured working memory for this session (CoALA working memory),
     # parallel to the message checkpoint. Lazily built.
     def working_memory
-      @working_memory ||= WorkingMemory.new(user_id: @user_id, session_id: @session_id)
+      @working_memory ||= WorkingMemory.new(
+        user_id: @user_id,
+        session_id: @session_id,
+        store: build_short_term_store(@cipher)
+      )
     end
 
     # Episodic long-term memory (CoALA): records and retrieves agent trajectories.
     # Additive — coexists with the semantic store (file/graph). Lazily built.
     def episodic
-      @episodic ||= LongTerm::Episodic::Memory.new(user_id: @user_id)
+      @episodic ||= LongTerm::Episodic::Memory.new(
+        user_id: @user_id,
+        storage: LongTerm::Episodic::Storages.build(cipher: @cipher),
+        cipher: @cipher
+      )
     end
 
     # Procedural long-term memory (Voyager-style skill library). Lazily built.
     def procedural
-      @procedural ||= LongTerm::Procedural::Memory.new(user_id: @user_id)
+      @procedural ||= LongTerm::Procedural::Memory.new(
+        user_id: @user_id,
+        storage: LongTerm::Procedural::Storages.build(cipher: @cipher),
+        cipher: @cipher
+      )
     end
 
     # Reflects over recent episodes and writes distilled insights to the
@@ -53,6 +76,26 @@ module Llmemory
       Actions::Reason.call(working_memory: working_memory, template: template, into: into, parse: parse, llm: @llm)
     end
 
+    # Mines recent episodes for reusable skills (Voyager-style). Human-in-the-loop
+    # by default: returns skill proposals and writes nothing. With
+    # `auto_register: true`, registers them in procedural memory (with provenance
+    # back to the source episodes) and returns the new skill ids.
+    def mine_skills!(window: SkillMining::Miner::DEFAULT_WINDOW, outcomes: nil, auto_register: false)
+      SkillMining::Miner.new(episodic: episodic, procedural: procedural, llm: @llm)
+        .mine(window: window, outcomes: outcomes, auto_register: auto_register)
+    end
+
+    # Cognitive maintenance pass: consolidate -> reflect -> mine skills -> expire,
+    # in one step, closing the CoALA learning loop. Each step is isolated; a
+    # failure in one is captured in the report and never aborts the others.
+    def maintain!(**opts)
+      Maintenance::CognitivePass.run!(
+        @user_id,
+        memory: self, episodic: episodic, procedural: procedural, semantic: @long_term, llm: @llm,
+        **opts
+      )
+    end
+
     def add_message(role:, content:)
       msgs = messages
       msgs << { role: role.to_sym, content: content.to_s }
@@ -301,14 +344,23 @@ module Llmemory
       when :graph_based
         LongTerm::GraphBased::Memory.new(
           user_id: @user_id,
-          storage: LongTerm::GraphBased::Storages.build,
+          storage: LongTerm::GraphBased::Storages.build(cipher: @cipher),
+          cipher: @cipher,
           **llm_opts
         )
       else
-        LongTerm::FileBased::Memory.new(user_id: @user_id, storage: LongTerm::FileBased::Storages.build, **llm_opts)
+        LongTerm::FileBased::Memory.new(
+          user_id: @user_id,
+          storage: LongTerm::FileBased::Storages.build(cipher: @cipher),
+          **llm_opts
+        )
       end
     end
 
+    def build_short_term_store(cipher)
+      ShortTerm::Stores.build(cipher: cipher)
+    end
+
     def save_state(messages:, last_flush_at: nil, last_compact_at: nil)
       state = { STATE_KEY_MESSAGES => messages, last_activity_at: Time.now }
       state[:last_flush_at] = last_flush_at if last_flush_at

data/lib/llmemory/memory_module.rb

@@ -6,10 +6,10 @@ module Llmemory
   # abstractions; this mixin gives any memory store the same agent-facing
   # surface so frameworks can treat them polymorphically:
   #
-  #   read(query, user_id:, limit:)  -> relevant entries (retrieval)
-  #   write(payload, ...)            -> ingest into the store (learning)
-  #   list(user_id:, limit:)         -> enumerate stored entries
-  #   stats(user_id:)                -> counts and metadata
+  #   read(query, user_id:, limit:)          -> relevant entries (retrieval)
+  #   write(payload, ...)                    -> ingest into the store (learning)
+  #   list(user_id:, limit:, offset:)        -> enumerate stored entries (paginated)
+  #   stats(user_id:)                        -> counts and metadata
   #
   # `read` defaults to the de-facto `search_candidates` interface the retrieval
   # Engine already relies on. `write`, `list` and `stats` are implemented by each
@@ -30,7 +30,7 @@ module Llmemory
       raise NotImplementedError, "#{self.class} must implement #write"
     end
 
-    def list(user_id: nil, limit: nil)
+    def list(user_id: nil, limit: nil, offset: nil)
       raise NotImplementedError, "#{self.class} must implement #list"
     end
 
@@ -40,9 +40,16 @@ module Llmemory
 
     # Removes entries by id (the same ids returned by #read) and records the
     # removal in a ForgetLog audit. Returns the number of entries removed.
+    #
+    # mode:
+    #   :soft (default) — soft-archive: entries are excluded from list/search/
+    #     retrieval but remain accessible by id (think "trash"). Reversible if
+    #     the store supports it.
+    #   :hard           — physical deletion. Irreversible.
+    #
     # Implemented by stores with a clear deletion model; others may not support
     # it (CoALA-style "unlearning" is understudied; deletion semantics differ).
-    def forget(ids:, reason: nil)
+    def forget(ids:, reason: nil, mode: :soft)
       raise NotImplementedError, "#{self.class} does not support #forget"
     end
 

data/lib/llmemory/reflection/reflector.rb

@@ -30,27 +30,31 @@ module Llmemory
       # Reflects over the most recent `window` episodes and writes the resulting
       # insights to semantic memory. Returns the ids of the stored insights.
       def reflect(window: 10, category: DEFAULT_CATEGORY)
-        episodes = @episodic.recent_episodes(limit: window)
-        return [] if episodes.empty?
-
-        insights = distill(episodes)
-        return [] if insights.empty?
-
-        sources = episodes.map(&:id).compact.map { |id| { type: "episode", id: id } }
-
-        insights.filter_map do |insight|
-          provenance = Llmemory::Provenance.build(
-            method: "reflection",
-            sources: sources,
-            confidence: insight[:confidence]
-          )
-          @semantic.remember_fact(
-            content: insight[:content],
-            category: category,
-            importance: insight[:confidence] || DEFAULT_IMPORTANCE,
-            provenance: provenance
-          )
+        result = []
+        Llmemory::Instrumentation.instrument(:reflect, window: window, category: category) do
+          episodes = @episodic.recent_episodes(limit: window)
+          next if episodes.empty?
+
+          insights = distill(episodes)
+          next if insights.empty?
+
+          sources = episodes.map(&:id).compact.map { |id| { type: "episode", id: id } }
+
+          result = insights.filter_map do |insight|
+            provenance = Llmemory::Provenance.build(
+              method: "reflection",
+              sources: sources,
+              confidence: insight[:confidence]
+            )
+            @semantic.remember_fact(
+              content: insight[:content],
+              category: category,
+              importance: insight[:confidence] || DEFAULT_IMPORTANCE,
+              provenance: provenance
+            )
+          end
         end
+        result
       end
 
       private

data/lib/llmemory/retrieval/engine.rb

@@ -24,9 +24,13 @@ module Llmemory
 
       def retrieve_for_inference(user_message, user_id: nil, max_tokens: nil)
         user_id ||= @memory.respond_to?(:user_id) ? @memory.user_id : nil
-        search_query = generate_query(user_message)
-        ranked = ranked_candidates(search_query, user_id, user_message)
-        @assembler.assemble(ranked, max_tokens: max_tokens)
+        result = nil
+        Llmemory::Instrumentation.instrument(:retrieve, user_id: user_id, query_chars: user_message.to_s.length) do
+          search_query = generate_query(user_message)
+          ranked = ranked_candidates(search_query, user_id, user_message)
+          result = @assembler.assemble(ranked, max_tokens: max_tokens)
+        end
+        result
       end
 
       # Multi-hop retrieval (CoALA: integrating retrieval and reasoning). After
@@ -42,21 +46,26 @@ module Llmemory
         user_id ||= @memory.respond_to?(:user_id) ? @memory.user_id : nil
         reasoner ||= method(:default_followup_query)
 
-        query = generate_query(user_message)
-        seen = []
-        accumulated = []
-        hop = 0
-
-        while hop < max_hops && live_query?(query) && !seen.include?(query)
-          seen << query
-          accumulated = merge_candidates(accumulated, ranked_candidates(query, user_id, query))
-          hop += 1
-          break if hop >= max_hops
+        final = nil
+        hops_done = 0
+        Llmemory::Instrumentation.instrument(:iterative_retrieve, user_id: user_id, query_chars: user_message.to_s.length, max_hops: max_hops) do
+          query = generate_query(user_message)
+          seen = []
+          accumulated = []
+          hop = 0
+
+          while hop < max_hops && live_query?(query) && !seen.include?(query)
+            seen << query
+            accumulated = merge_candidates(accumulated, ranked_candidates(query, user_id, query))
+            hop += 1
+            break if hop >= max_hops
+
+            query = reasoner.call(user_message, accumulated, hop).to_s.strip
+          end
+          hops_done = hop
 
-          query = reasoner.call(user_message, accumulated, hop).to_s.strip
+          final = accumulated.sort_by { |c| -(c[:temporal_score] || c[:score] || 0) }
         end
-
-        final = accumulated.sort_by { |c| -(c[:temporal_score] || c[:score] || 0) }
         @assembler.assemble(final, max_tokens: max_tokens)
       end
 

data/lib/llmemory/short_term/checkpoint.rb

@@ -7,9 +7,10 @@ module Llmemory
     class Checkpoint
       DEFAULT_SESSION_ID = "default"
 
-      def initialize(user_id:, session_id: DEFAULT_SESSION_ID, store: nil)
+      def initialize(user_id:, session_id: DEFAULT_SESSION_ID, store: nil, cipher: nil)
         @user_id = user_id
         @session_id = session_id
+        @cipher = cipher
         @store = store || build_store
       end
 
@@ -28,7 +29,7 @@ module Llmemory
       private
 
       def build_store
-        Stores.build
+        Stores.build(cipher: @cipher)
       end
     end
   end

data/lib/llmemory/short_term/stores/active_record_store.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../../crypto/field_helpers"
 
 module Llmemory
   module ShortTerm
     module Stores
       class ActiveRecordStore < Base
-        def initialize
+        include Llmemory::Crypto::FieldHelpers
+
+        def initialize(cipher: nil)
+          @cipher = cipher || Llmemory.build_cipher
           self.class.load_model!
         end
 
@@ -22,7 +26,7 @@ module Llmemory
             user_id: user_id,
             session_id: session_id
           )
-          record.state = state
+          record.state = cipher.enabled? ? serialize_state(state) : state
           record.updated_at = Time.current
           record.save!
           true
@@ -34,8 +38,13 @@ module Llmemory
             session_id: session_id
           )
           return nil unless record
+
           raw = record.state
-          raw.is_a?(Hash) ? raw.transform_keys(&:to_sym) : deserialize(raw)
+          if raw.is_a?(Hash)
+            raw.transform_keys(&:to_sym)
+          else
+            deserialize_state(raw)
+          end
         end
 
         def delete(user_id, session_id)
@@ -53,13 +62,6 @@ module Llmemory
         def list_sessions(user_id:)
           Llmemory::ShortTerm::Stores::ActiveRecordCheckpoint.where(user_id: user_id).pluck(:session_id)
         end
-
-        private
-
-        def deserialize(data)
-          return data if data.is_a?(Hash)
-          JSON.parse(data.to_s, symbolize_names: true)
-        end
       end
     end
   end

data/lib/llmemory/short_term/stores/memory_store.rb

@@ -6,7 +6,7 @@ module Llmemory
   module ShortTerm
     module Stores
       class MemoryStore < Base
-        def initialize
+        def initialize(cipher: nil)
           @store = {}
         end
 

data/lib/llmemory/short_term/stores/postgres_store.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../../crypto/field_helpers"
 
 module Llmemory
   module ShortTerm
     module Stores
       class PostgresStore < Base
-        def initialize(database_url: nil)
+        include Llmemory::Crypto::FieldHelpers
+
+        def initialize(database_url: nil, cipher: nil)
           @database_url = database_url || Llmemory.configuration.database_url
           @connection = nil
+          @cipher = cipher || Llmemory.build_cipher
         end
 
         def save(user_id, session_id, state)
@@ -81,13 +85,15 @@ module Llmemory
         end
 
         def serialize(state)
-          require "json"
-          JSON.generate(state)
+          payload = serialize_state(state)
+          cipher.enabled? ? JSON.generate(payload) : payload
         end
 
         def deserialize(data)
-          require "json"
-          JSON.parse(data, symbolize_names: true)
+          if data.is_a?(String) && !cipher.encrypted?(data)
+            data = JSON.parse(data)
+          end
+          deserialize_state(data)
         end
       end
     end

data/lib/llmemory/short_term/stores/redis_store.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../../crypto/field_helpers"
 
 module Llmemory
   module ShortTerm
     module Stores
       class RedisStore < Base
-        def initialize(redis_url: nil)
+        include Llmemory::Crypto::FieldHelpers
+
+        def initialize(redis_url: nil, cipher: nil)
           @redis_url = redis_url || Llmemory.configuration.redis_url
           @redis = nil
+          @cipher = cipher || Llmemory.build_cipher
         end
 
         def save(user_id, session_id, state)
@@ -50,13 +54,11 @@ module Llmemory
         end
 
         def serialize(state)
-          require "json"
-          JSON.generate(state)
+          serialize_state(state)
         end
 
         def deserialize(data)
-          require "json"
-          JSON.parse(data, symbolize_names: true)
+          deserialize_state(data)
         end
       end
     end

data/lib/llmemory/short_term/stores.rb

@@ -10,16 +10,17 @@ module Llmemory
     module Stores
       # Single source of truth for selecting a short-term store backend.
       # Shared by Checkpoint, SessionLifecycle and WorkingMemory.
-      def self.build(store_type = nil)
+      def self.build(store_type = nil, cipher: nil)
+        resolved_cipher = cipher || Llmemory.build_cipher
         case (store_type || Llmemory.configuration.short_term_store).to_sym
-        when :memory then MemoryStore.new
-        when :redis then RedisStore.new
-        when :postgres then PostgresStore.new
+        when :memory then MemoryStore.new(cipher: resolved_cipher)
+        when :redis then RedisStore.new(cipher: resolved_cipher)
+        when :postgres then PostgresStore.new(cipher: resolved_cipher)
         when :active_record, :activerecord
           require_relative "stores/active_record_store"
-          ActiveRecordStore.new
+          ActiveRecordStore.new(cipher: resolved_cipher)
         else
-          MemoryStore.new
+          MemoryStore.new(cipher: resolved_cipher)
         end
       end
     end