llmemory 0.2.1 → 0.2.3

data/lib/llmemory/long_term/episodic/storage.rb

@@ -12,17 +12,24 @@ module Llmemory
       Storage = Storages::MemoryStorage
 
       module Storages
-        def self.build(store: nil, base_path: nil, database_url: nil)
+        def self.build(store: nil, base_path: nil, database_url: nil, cipher: nil)
+          resolved_cipher = cipher || Llmemory.build_cipher
           case (store || Llmemory.configuration.long_term_store).to_s.to_sym
           when :memory
             MemoryStorage.new
           when :file
-            FileStorage.new(base_path: base_path || Llmemory.configuration.long_term_storage_path)
+            FileStorage.new(
+              base_path: base_path || Llmemory.configuration.long_term_storage_path,
+              cipher: resolved_cipher
+            )
           when :postgres, :database
-            DatabaseStorage.new(database_url: database_url || Llmemory.configuration.database_url)
+            DatabaseStorage.new(
+              database_url: database_url || Llmemory.configuration.database_url,
+              cipher: resolved_cipher
+            )
           when :active_record, :activerecord
             require_relative "storages/active_record_storage"
-            ActiveRecordStorage.new
+            ActiveRecordStorage.new(cipher: resolved_cipher)
           else
             MemoryStorage.new
           end

data/lib/llmemory/long_term/episodic/storages/active_record_storage.rb

@@ -4,6 +4,7 @@ require "json"
 require "securerandom"
 require "time"
 require_relative "base"
+require_relative "../../../crypto/field_helpers"
 
 module Llmemory
   module LongTerm
@@ -13,7 +14,10 @@ module Llmemory
         # AR auto-deserializes jsonb to a Hash (string keys), which Episode.from_h
         # handles. Mirrors the file-based ActiveRecordStorage pattern.
         class ActiveRecordStorage < Base
-          def initialize
+          include Llmemory::Crypto::FieldHelpers
+
+          def initialize(cipher: nil)
+            @cipher = cipher || Llmemory.build_cipher
             self.class.load_models!
           end
 
@@ -30,8 +34,8 @@ module Llmemory
             data["created_at"] ||= Time.now.utc.iso8601
             rec = LlmemoryEpisode.find_or_initialize_by(id: id)
             rec.user_id = user_id
-            rec.data = data
-            rec.search_text = searchable_text(data)
+            rec.data = cipher.enabled? ? enc_json(data) : data
+            rec.search_text = enc(searchable_text(data))
             rec.created_at ||= Time.current
             rec.save!
             id
@@ -39,28 +43,40 @@ module Llmemory
 
           def get_episode(user_id, id)
             rec = LlmemoryEpisode.find_by(user_id: user_id, id: id)
-            rec&.data
+            return nil unless rec
+
+            decode_data(rec.data)
           end
 
-          def list_episodes(user_id, limit: nil)
-            scope = LlmemoryEpisode.where(user_id: user_id).order(created_at: :desc)
+          def list_episodes(user_id, limit: nil, offset: nil)
+            scope = LlmemoryEpisode.where(user_id: user_id, archived_at: nil).order(created_at: :desc)
             scope = scope.limit(limit) if limit && limit.to_i.positive?
-            scope.map(&:data)
+            scope = scope.offset(offset) if offset && offset.to_i.positive?
+            scope.map { |r| decode_data(r.data) }
           end
 
           def search_episodes(user_id, query)
-            token_scope(LlmemoryEpisode.where(user_id: user_id), "search_text", query)
-              .order(created_at: :desc).map(&:data)
+            token_scope(LlmemoryEpisode.where(user_id: user_id, archived_at: nil), "search_text", query)
+              .order(created_at: :desc).map { |r| decode_data(r.data) }
           end
 
           def count_episodes(user_id)
-            LlmemoryEpisode.where(user_id: user_id).count
+            LlmemoryEpisode.where(user_id: user_id, archived_at: nil).count
           end
 
           def delete_episodes(user_id, ids)
             LlmemoryEpisode.where(user_id: user_id, id: Array(ids).map(&:to_s)).delete_all
           end
 
+          def archive_episodes(user_id, ids)
+            LlmemoryEpisode.where(user_id: user_id, id: Array(ids).map(&:to_s), archived_at: nil)
+              .update_all(archived_at: Time.current)
+          end
+
+          def expired_episode_ids(user_id, cutoff:)
+            LlmemoryEpisode.where(user_id: user_id, archived_at: nil).where("created_at < ?", cutoff).pluck(:id)
+          end
+
           def list_users
             LlmemoryEpisode.distinct.pluck(:user_id)
           end
@@ -86,6 +102,13 @@ module Llmemory
             end
             parts.compact.join("\n")
           end
+
+          def decode_data(raw)
+            return raw.transform_keys(&:to_sym) if raw.is_a?(Hash)
+            return dec_json(raw) if raw.is_a?(String) && cipher.encrypted?(raw)
+
+            raw
+          end
         end
       end
     end

data/lib/llmemory/long_term/episodic/storages/base.rb

@@ -16,8 +16,8 @@ module Llmemory
             raise NotImplementedError, "#{self.class}#get_episode must be implemented"
           end
 
-          # Newest first. Optionally capped by limit.
-          def list_episodes(user_id, limit: nil)
+          # Newest first. Optionally paginated with offset/limit.
+          def list_episodes(user_id, limit: nil, offset: nil)
             raise NotImplementedError, "#{self.class}#list_episodes must be implemented"
           end
 
@@ -34,6 +34,19 @@ module Llmemory
             raise NotImplementedError, "#{self.class}#delete_episodes must be implemented"
           end
 
+          # Soft-archives episodes by id (sets archived_at on the record). Archived
+          # episodes are excluded from list_episodes / search_episodes / count_episodes
+          # but remain accessible via get_episode. Returns the number archived.
+          def archive_episodes(user_id, ids)
+            raise NotImplementedError, "#{self.class}#archive_episodes must be implemented"
+          end
+
+          # Returns episodes whose created_at is older than the cutoff and that are
+          # not already archived. Used by the TTL maintenance job.
+          def expired_episode_ids(user_id, cutoff:)
+            raise NotImplementedError, "#{self.class}#expired_episode_ids must be implemented"
+          end
+
           def list_users
             raise NotImplementedError, "#{self.class}#list_users must be implemented"
           end

data/lib/llmemory/long_term/episodic/storages/database_storage.rb

@@ -4,6 +4,7 @@ require "json"
 require "securerandom"
 require "time"
 require_relative "base"
+require_relative "../../../crypto/field_helpers"
 
 module Llmemory
   module LongTerm
@@ -13,9 +14,12 @@ module Llmemory
         # (plus id/user_id/created_at and a denormalized search_text for keyword
         # search), mirroring the file-based DatabaseStorage pattern.
         class DatabaseStorage < 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_episode(user_id, episode)
@@ -23,11 +27,12 @@ module Llmemory
             id = episode[:id] || episode["id"] || "ep_#{SecureRandom.hex(8)}"
             data = symbolize(episode).merge(id: id, user_id: user_id)
             data[:created_at] ||= Time.now.utc.iso8601
+            search = searchable_text(data)
             conn.exec_params(
               "INSERT INTO llmemory_episodes (id, user_id, data, search_text, created_at) " \
               "VALUES ($1, $2, $3::jsonb, $4, $5) " \
               "ON CONFLICT (id) DO UPDATE SET data = $3::jsonb, search_text = $4",
-              [id, user_id, JSON.generate(data), searchable_text(data), created_at_value(data)]
+              [id, user_id, store_data(data), enc(search), created_at_value(data)]
             )
             id
           end
@@ -38,10 +43,11 @@ module Llmemory
             rows.any? ? parse_data(rows.first["data"]) : nil
           end
 
-          def list_episodes(user_id, limit: nil)
+          def list_episodes(user_id, limit: nil, offset: nil)
             ensure_tables!
-            sql = "SELECT data FROM llmemory_episodes WHERE user_id = $1 ORDER BY created_at DESC"
+            sql = "SELECT data FROM llmemory_episodes WHERE user_id = $1 AND archived_at IS NULL ORDER BY created_at DESC"
             sql += " LIMIT #{limit.to_i}" if limit && limit.to_i.positive?
+            sql += " OFFSET #{offset.to_i}" if offset && offset.to_i.positive?
             conn.exec_params(sql, [user_id]).map { |r| parse_data(r["data"]) }
           end
 
@@ -49,14 +55,14 @@ module Llmemory
             ensure_tables!
             suffix, params = token_filter("search_text", query, 2)
             conn.exec_params(
-              "SELECT data FROM llmemory_episodes WHERE user_id = $1#{suffix} ORDER BY created_at DESC",
+              "SELECT data FROM llmemory_episodes WHERE user_id = $1 AND archived_at IS NULL#{suffix} ORDER BY created_at DESC",
               [user_id, *params]
             ).map { |r| parse_data(r["data"]) }
           end
 
           def count_episodes(user_id)
             ensure_tables!
-            conn.exec_params("SELECT COUNT(*) AS c FROM llmemory_episodes WHERE user_id = $1", [user_id]).first["c"].to_i
+            conn.exec_params("SELECT COUNT(*) AS c FROM llmemory_episodes WHERE user_id = $1 AND archived_at IS NULL", [user_id]).first["c"].to_i
           end
 
           def delete_episodes(user_id, ids)
@@ -66,6 +72,24 @@ module Llmemory
             end
           end
 
+          def archive_episodes(user_id, ids)
+            ensure_tables!
+            Array(ids).sum do |id|
+              conn.exec_params(
+                "UPDATE llmemory_episodes SET archived_at = NOW() WHERE user_id = $1 AND id = $2 AND archived_at IS NULL",
+                [user_id, id]
+              ).cmd_tuples
+            end
+          end
+
+          def expired_episode_ids(user_id, cutoff:)
+            ensure_tables!
+            conn.exec_params(
+              "SELECT id FROM llmemory_episodes WHERE user_id = $1 AND archived_at IS NULL AND created_at < $2",
+              [user_id, cutoff.iso8601]
+            ).map { |r| r["id"] }
+          end
+
           def list_users
             ensure_tables!
             conn.exec("SELECT DISTINCT user_id FROM llmemory_episodes").map { |r| r["user_id"] }
@@ -87,9 +111,11 @@ module Llmemory
                 user_id TEXT NOT NULL,
                 data JSONB NOT NULL DEFAULT '{}'::jsonb,
                 search_text TEXT,
-                created_at TIMESTAMPTZ NOT NULL
+                created_at TIMESTAMPTZ NOT NULL,
+                archived_at TIMESTAMPTZ
               );
               CREATE INDEX IF NOT EXISTS idx_llmemory_episodes_user_id ON llmemory_episodes(user_id);
+              ALTER TABLE llmemory_episodes ADD COLUMN IF NOT EXISTS archived_at TIMESTAMPTZ;
             SQL
           end
 
@@ -103,11 +129,28 @@ module Llmemory
           end
 
           def parse_data(value)
-            JSON.parse(value.to_s, symbolize_names: true)
+            if value.is_a?(Hash)
+              return value.transform_keys(&:to_sym)
+            end
+
+            str = value.to_s
+            if cipher.encrypted?(str)
+              cipher.decrypt_json(str)
+            else
+              JSON.parse(str, symbolize_names: true)
+            end
           rescue JSON::ParserError
             {}
           end
 
+          def store_data(data)
+            if cipher.enabled?
+              JSON.generate(enc_json(data))
+            else
+              JSON.generate(data)
+            end
+          end
+
           def symbolize(hash)
             hash.each_with_object({}) { |(k, v), acc| acc[k.to_sym] = v }
           end

data/lib/llmemory/long_term/episodic/storages/file_storage.rb

@@ -4,22 +4,26 @@ require "fileutils"
 require "json"
 require "time"
 require_relative "base"
+require_relative "../../../crypto/field_helpers"
 
 module Llmemory
   module LongTerm
     module Episodic
       module Storages
         class FileStorage < Base
-          def initialize(base_path: nil)
+          include Llmemory::Crypto::FieldHelpers
+
+          def initialize(base_path: nil, cipher: nil)
             @base_path = base_path || Llmemory.configuration.long_term_storage_path || "./llmemory_data"
             @base_path = File.expand_path(@base_path)
+            @cipher = cipher || Llmemory.build_cipher
           end
 
           def save_episode(user_id, episode)
             id = episode[:id] || episode["id"] || "ep_#{next_seq(user_id)}"
             data = stringify_for_json(episode).merge("id" => id, "user_id" => user_id)
             data["created_at"] ||= Time.now.iso8601
-            File.write(episode_path(user_id, id), JSON.generate(data))
+            write_episode_file(episode_path(user_id, id), data)
             id
           end
 
@@ -29,20 +33,19 @@ module Llmemory
             load_episode(path)
           end
 
-          def list_episodes(user_id, limit: nil)
-            sorted = all_episodes(user_id).sort_by { |e| e[:created_at] }.reverse
+          def list_episodes(user_id, limit: nil, offset: nil)
+            sorted = active_episodes(user_id).sort_by { |e| e[:created_at] }.reverse
+            sorted = sorted.drop(offset.to_i) if offset && offset.to_i.positive?
             limit && limit.to_i.positive? ? sorted.first(limit.to_i) : sorted
           end
 
           def search_episodes(user_id, query)
             return list_episodes(user_id) if query.to_s.strip.empty?
-            all_episodes(user_id).select { |e| Llmemory::Tokenizer.matches?(episode_text(e), query) }
+            active_episodes(user_id).select { |e| Llmemory::Tokenizer.matches?(episode_text(e), query) }
           end
 
           def count_episodes(user_id)
-            dir = user_path(user_id, "episodes")
-            return 0 unless Dir.exist?(dir)
-            Dir.children(dir).count { |f| f.end_with?(".json") }
+            active_episodes(user_id).size
           end
 
           def delete_episodes(user_id, ids)
@@ -54,6 +57,24 @@ module Llmemory
             end
           end
 
+          def archive_episodes(user_id, ids)
+            Array(ids).map(&:to_s).count do |id|
+              path = episode_path(user_id, id)
+              next false unless File.file?(path)
+              data = load_episode_raw(path)
+              next false if data["archived_at"]
+              data["archived_at"] = Time.now.iso8601
+              write_episode_file(path, data)
+              true
+            end
+          end
+
+          def expired_episode_ids(user_id, cutoff:)
+            active_episodes(user_id)
+              .select { |e| (e[:created_at] || Time.now) < cutoff }
+              .map { |e| e[:id].to_s }
+          end
+
           def list_users
             return [] unless Dir.exist?(@base_path)
             Dir.children(@base_path).select { |d| Dir.exist?(File.join(@base_path, d, "episodes")) }
@@ -61,6 +82,10 @@ module Llmemory
 
           private
 
+          def active_episodes(user_id)
+            all_episodes(user_id).reject { |e| e[:archived_at] }
+          end
+
           def all_episodes(user_id)
             dir = user_path(user_id, "episodes")
             return [] unless Dir.exist?(dir)
@@ -68,13 +93,26 @@ module Llmemory
           end
 
           def load_episode(path)
-            data = JSON.parse(File.read(path), symbolize_names: true)
+            data = load_episode_raw(path)
+            return nil unless data
+
             data[:created_at] = parse_time(data[:created_at])
             data
           rescue JSON::ParserError
             nil
           end
 
+          def load_episode_raw(path)
+            raw = File.read(path)
+            json = cipher.enabled? && cipher.encrypted?(raw) ? cipher.decrypt(raw) : raw
+            JSON.parse(json, symbolize_names: true)
+          end
+
+          def write_episode_file(path, data)
+            payload = JSON.generate(data)
+            File.write(path, cipher.enabled? ? cipher.encrypt(payload) : payload)
+          end
+
           def episode_text(episode)
             parts = [episode[:summary], episode[:outcome]]
             Array(episode[:steps]).each do |s|

data/lib/llmemory/long_term/episodic/storages/memory_storage.rb

@@ -25,18 +25,19 @@ module Llmemory
             @episodes[user_id].find { |e| e[:id] == id }
           end
 
-          def list_episodes(user_id, limit: nil)
-            sorted = @episodes[user_id].sort_by { |e| e[:created_at] }.reverse
+          def list_episodes(user_id, limit: nil, offset: nil)
+            sorted = active_episodes(user_id).sort_by { |e| as_time(e[:created_at]) }.reverse
+            sorted = sorted.drop(offset.to_i) if offset && offset.to_i.positive?
             limit && limit.to_i.positive? ? sorted.first(limit.to_i) : sorted
           end
 
           def search_episodes(user_id, query)
             return list_episodes(user_id) if query.to_s.strip.empty?
-            @episodes[user_id].select { |e| Llmemory::Tokenizer.matches?(episode_text(e), query) }
+            active_episodes(user_id).select { |e| Llmemory::Tokenizer.matches?(episode_text(e), query) }
           end
 
           def count_episodes(user_id)
-            @episodes[user_id].size
+            active_episodes(user_id).size
           end
 
           def delete_episodes(user_id, ids)
@@ -46,12 +47,42 @@ module Llmemory
             before - @episodes[user_id].size
           end
 
+          def archive_episodes(user_id, ids)
+            ids = Array(ids).map(&:to_s)
+            count = 0
+            @episodes[user_id].each do |e|
+              next unless ids.include?(e[:id].to_s)
+              next if e[:archived_at]
+              e[:archived_at] = Time.now
+              count += 1
+            end
+            count
+          end
+
+          def expired_episode_ids(user_id, cutoff:)
+            active_episodes(user_id)
+              .select { |e| as_time(e[:created_at]) < cutoff }
+              .map { |e| e[:id].to_s }
+          end
+
           def list_users
             @episodes.keys
           end
 
           private
 
+          def active_episodes(user_id)
+            @episodes[user_id].reject { |e| e[:archived_at] }
+          end
+
+          def as_time(value)
+            return Time.now if value.nil?
+            return value if value.is_a?(Time)
+            Time.parse(value.to_s)
+          rescue ArgumentError
+            Time.now
+          end
+
           def symbolize(hash)
             hash.each_with_object({}) { |(k, v), acc| acc[k.to_sym] = v }
           end

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

@@ -108,11 +108,15 @@ module Llmemory
         # --- MemoryModule uniform interface ---
 
         def write(payload, **_meta)
-          memorize(payload)
+          result = nil
+          Llmemory::Instrumentation.instrument(:memory_write, memory_type: "file_based", user_id: @user_id) do
+            result = memorize(payload)
+          end
+          result
         end
 
-        def list(user_id: nil, limit: nil)
-          @storage.list_items(user_id: user_id || @user_id, limit: limit)
+        def list(user_id: nil, limit: nil, offset: nil)
+          @storage.list_items(user_id: user_id || @user_id, limit: limit, offset: offset)
         end
 
         def stats(user_id: nil)
@@ -120,7 +124,10 @@ module Llmemory
         end
 
         # Removes items/resources by id and records the removal in the audit log.
-        def forget(ids:, reason: nil)
+        # Note: file-based storages currently implement `archive_*` as physical
+        # removal — `mode: :soft` and `mode: :hard` are functionally equivalent
+        # here. Kept for API uniformity.
+        def forget(ids:, reason: nil, mode: :soft)
           requested = Array(ids).map(&:to_s)
           existing = (@storage.get_all_items(@user_id) + @storage.get_all_resources(@user_id))
             .map { |r| (r[:id] || r["id"]).to_s }
@@ -128,6 +135,7 @@ module Llmemory
           @storage.archive_items(@user_id, removed)
           @storage.archive_resources(@user_id, removed)
           forget_log.record(@user_id, memory_type: "file_based", ids: removed, reason: reason)
+          Llmemory::Instrumentation.instrument(:memory_forget, memory_type: "file_based", user_id: @user_id, count: removed.size, mode: mode)
           removed.size
         end
 

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

@@ -14,17 +14,24 @@ module Llmemory
       Storage = Storages::MemoryStorage
 
       module Storages
-        def self.build(store: nil, base_path: nil, database_url: nil)
+        def self.build(store: nil, base_path: nil, database_url: nil, cipher: nil)
+          resolved_cipher = cipher || Llmemory.build_cipher
           case (store || Llmemory.configuration.long_term_store).to_s.to_sym
           when :memory
             MemoryStorage.new
           when :file
-            FileStorage.new(base_path: base_path || Llmemory.configuration.long_term_storage_path)
+            FileStorage.new(
+              base_path: base_path || Llmemory.configuration.long_term_storage_path,
+              cipher: resolved_cipher
+            )
           when :postgres, :database
-            DatabaseStorage.new(database_url: database_url || Llmemory.configuration.database_url)
+            DatabaseStorage.new(
+              database_url: database_url || Llmemory.configuration.database_url,
+              cipher: resolved_cipher
+            )
           when :active_record, :activerecord
             require_relative "storages/active_record_storage"
-            ActiveRecordStorage.new
+            ActiveRecordStorage.new(cipher: resolved_cipher)
           else
             MemoryStorage.new
           end

data/lib/llmemory/long_term/file_based/storages/active_record_storage.rb

@@ -2,13 +2,17 @@
 
 require "securerandom"
 require_relative "base"
+require_relative "../../../crypto/field_helpers"
 
 module Llmemory
   module LongTerm
     module FileBased
       module Storages
         class ActiveRecordStorage < Base
-          def initialize
+          include Llmemory::Crypto::FieldHelpers
+
+          def initialize(cipher: nil)
+            @cipher = cipher || Llmemory.build_cipher
             self.class.load_models!
           end
 
@@ -24,7 +28,7 @@ module Llmemory
             LlmemoryResource.create!(
               id: id,
               user_id: user_id,
-              text: text,
+              text: enc(text),
               created_at: Time.current
             )
             id
@@ -36,24 +40,26 @@ module Llmemory
               id: id,
               user_id: user_id,
               category: category,
-              content: content,
+              content: enc(content),
               source_resource_id: source_resource_id,
               created_at: Time.current
             }
             attrs[:importance] = importance if LlmemoryItem.column_names.include?("importance")
-            attrs[:provenance] = provenance if provenance && LlmemoryItem.column_names.include?("provenance")
+            if provenance && LlmemoryItem.column_names.include?("provenance")
+              attrs[:provenance] = cipher.enabled? ? enc_json(provenance) : provenance
+            end
             LlmemoryItem.create!(attrs)
             id
           end
 
           def load_category(user_id, category_name)
             rec = LlmemoryCategory.find_by(user_id: user_id, category_name: category_name)
-            rec ? rec.content.to_s : ""
+            rec ? dec(rec.content.to_s) : ""
           end
 
           def save_category(user_id, category_name, content)
             rec = LlmemoryCategory.find_or_initialize_by(user_id: user_id, category_name: category_name)
-            rec.content = content
+            rec.content = enc(content)
             rec.updated_at = Time.current
             rec.save!
             true
@@ -101,7 +107,7 @@ module Llmemory
               id: "item_#{SecureRandom.hex(8)}",
               user_id: user_id,
               category: merged_item[:category],
-              content: merged_item[:content],
+              content: enc(merged_item[:content]),
               source_resource_id: merged_item[:source_resource_id],
               created_at: created_at
             }
@@ -123,17 +129,19 @@ module Llmemory
              LlmemoryCategory.distinct.pluck(:user_id)).uniq
           end
 
-          def list_resources(user_id:, limit: nil)
+          def list_resources(user_id:, limit: nil, offset: nil)
             scope = LlmemoryResource.where(user_id: user_id).order(:created_at)
             scope = scope.limit(limit) if limit && limit.to_i.positive?
+            scope = scope.offset(offset) if offset && offset.to_i.positive?
             scope.map { |r| row_to_resource(r) }
           end
 
-          def list_items(user_id:, category: nil, limit: nil)
+          def list_items(user_id:, category: nil, limit: nil, offset: nil)
             scope = LlmemoryItem.where(user_id: user_id)
             scope = scope.where(category: category) if category
             scope = scope.order(:created_at)
             scope = scope.limit(limit) if limit && limit.to_i.positive?
+            scope = scope.offset(offset) if offset && offset.to_i.positive?
             scope.map { |r| row_to_item(r) }
           end
 
@@ -192,19 +200,19 @@ module Llmemory
             h = {
               id: r.id,
               category: r.category,
-              content: r.content,
+              content: dec(r.content),
               source_resource_id: r.source_resource_id,
               created_at: r.created_at
             }
             h[:importance] = r.respond_to?(:importance) ? (r.importance || 0.7).to_f : 0.7
-            h[:provenance] = r.provenance if r.respond_to?(:provenance)
+            h[:provenance] = parse_provenance(r.provenance) if r.respond_to?(:provenance)
             h
           end
 
           def row_to_resource(r)
             {
               id: r.id,
-              text: r.text,
+              text: dec(r.text),
               created_at: r.created_at
             }
           end

data/lib/llmemory/long_term/file_based/storages/base.rb

@@ -69,11 +69,11 @@ module Llmemory
             raise NotImplementedError, "#{self.class}#list_users must be implemented"
           end
 
-          def list_resources(user_id:, limit: nil)
+          def list_resources(user_id:, limit: nil, offset: nil)
             raise NotImplementedError, "#{self.class}#list_resources must be implemented"
           end
 
-          def list_items(user_id:, category: nil, limit: nil)
+          def list_items(user_id:, category: nil, limit: nil, offset: nil)
             raise NotImplementedError, "#{self.class}#list_items must be implemented"
           end