lex-agentic-memory 0.1.8 → 0.1.11

data/lib/legion/extensions/agentic/memory/trace/helpers/postgres_store.rb

@@ -0,0 +1,393 @@
+# frozen_string_literal: true
+
+require_relative 'hot_tier'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Memory
+        module Trace
+          module Helpers
+            # Write-through durable store backed by Legion::Data (PostgreSQL or MySQL).
+            # All writes go directly to the database — no in-memory dirty tracking, no flush.
+            # Scoped by tenant_id so multiple agents can share the same DB tables safely.
+            class PostgresStore
+              TRACES_TABLE = :memory_traces
+              ASSOCIATIONS_TABLE = :memory_associations
+
+              def initialize(tenant_id: nil)
+                @tenant_id = tenant_id
+              end
+
+              # Store (upsert) a trace by trace_id.
+              # Returns the trace_id on success, nil if the DB is not ready.
+              def store(trace)
+                return nil unless db_ready?
+
+                row = serialize_trace(trace)
+                begin
+                  db[TRACES_TABLE].insert_conflict(:replace).insert(row)
+                rescue Sequel::UniqueConstraintViolation
+                  db[TRACES_TABLE].where(trace_id: trace[:trace_id]).update(row.except(:trace_id))
+                end
+                HotTier.cache_trace(trace, tenant_id: @tenant_id) if HotTier.available?
+                trace[:trace_id]
+              rescue StandardError => e
+                log_warn("store failed: #{e.message}")
+                nil
+              end
+
+              # Retrieve a single trace by trace_id (tenant-scoped).
+              # Checks the Redis hot tier first; falls through to DB on a miss and caches the result.
+              # Returns a trace hash or nil.
+              def retrieve(trace_id)
+                if HotTier.available?
+                  cached = HotTier.fetch_trace(trace_id, tenant_id: @tenant_id)
+                  return cached if cached
+                end
+
+                return nil unless db_ready?
+
+                row = traces_ds.where(trace_id: trace_id).first
+                trace = row ? deserialize_trace(row) : nil
+                HotTier.cache_trace(trace, tenant_id: @tenant_id) if HotTier.available? && trace
+                trace
+              rescue StandardError => e
+                log_warn("retrieve failed: #{e.message}")
+                nil
+              end
+
+              # Retrieve traces by type, ordered by strength descending.
+              def retrieve_by_type(type, limit: 100, min_strength: 0.0)
+                return [] unless db_ready?
+
+                rows = traces_ds
+                       .where(trace_type: type.to_s)
+                       .where { strength >= min_strength }
+                       .order(Sequel.desc(:strength))
+                       .limit(limit)
+                       .all
+                rows.map { |r| deserialize_trace(r) }
+              rescue StandardError => e
+                log_warn("retrieve_by_type failed: #{e.message}")
+                []
+              end
+
+              # Retrieve traces whose domain_tags column contains the given tag string.
+              def retrieve_by_domain(tag, limit: 50)
+                return [] unless db_ready?
+
+                rows = traces_ds
+                       .where(Sequel.like(:domain_tags, "%#{tag}%"))
+                       .order(Sequel.desc(:strength))
+                       .limit(limit)
+                       .all
+                rows.map { |r| deserialize_trace(r) }
+              rescue StandardError => e
+                log_warn("retrieve_by_domain failed: #{e.message}")
+                []
+              end
+
+              # Return all traces for this tenant.
+              def all_traces
+                return [] unless db_ready?
+
+                traces_ds.all.map { |r| deserialize_trace(r) }
+              rescue StandardError => e
+                log_warn("all_traces failed: #{e.message}")
+                []
+              end
+
+              # Delete a trace and its association rows.
+              def delete(trace_id)
+                HotTier.evict_trace(trace_id, tenant_id: @tenant_id) if HotTier.available?
+                return unless db_ready?
+
+                db[ASSOCIATIONS_TABLE].where(trace_id_a: trace_id).delete
+                db[ASSOCIATIONS_TABLE].where(trace_id_b: trace_id).delete
+                db[TRACES_TABLE].where(trace_id: trace_id).delete
+              rescue StandardError => e
+                log_warn("delete failed: #{e.message}")
+              end
+
+              # Partial update of a trace by trace_id.
+              # Evicts the hot-tier entry so a stale cached version cannot be served.
+              def update(trace_id, **fields)
+                return unless db_ready?
+
+                db[TRACES_TABLE].where(trace_id: trace_id).update(map_update_fields(fields))
+                HotTier.evict_trace(trace_id, tenant_id: @tenant_id) if HotTier.available?
+              rescue StandardError => e
+                log_warn("update failed: #{e.message}")
+              end
+
+              # Create or increment a coactivation association between two traces.
+              def record_coactivation(id_a, id_b)
+                return unless db_ready?
+                return if id_a == id_b
+
+                now = Time.now.utc
+                existing = db[ASSOCIATIONS_TABLE]
+                           .where(trace_id_a: id_a, trace_id_b: id_b)
+                           .first
+
+                if existing
+                  db[ASSOCIATIONS_TABLE]
+                    .where(id: existing[:id])
+                    .update(
+                      coactivation_count: existing[:coactivation_count] + 1,
+                      updated_at:         now
+                    )
+                else
+                  db[ASSOCIATIONS_TABLE].insert(
+                    trace_id_a:         id_a,
+                    trace_id_b:         id_b,
+                    coactivation_count: 1,
+                    linked:             false,
+                    tenant_id:          @tenant_id,
+                    created_at:         now,
+                    updated_at:         now
+                  )
+                end
+              rescue StandardError => e
+                log_warn("record_coactivation failed: #{e.message}")
+              end
+
+              # Return the set of trace IDs associated with a given trace (bidirectional).
+              def associations_for(trace_id)
+                return [] unless db_ready?
+
+                a_side = db[ASSOCIATIONS_TABLE]
+                         .where(trace_id_a: trace_id)
+                         .select_map(:trace_id_b)
+                b_side = db[ASSOCIATIONS_TABLE]
+                         .where(trace_id_b: trace_id)
+                         .select_map(:trace_id_a)
+                (a_side + b_side).uniq
+              rescue StandardError => e
+                log_warn("associations_for failed: #{e.message}")
+                []
+              end
+
+              # BFS traversal starting from start_id.
+              # Returns an array of { trace_id:, depth:, path: } hashes.
+              def walk_associations(start_id:, max_hops: 12, min_strength: 0.1)
+                return [] unless db_ready?
+
+                start_row = traces_ds.where(trace_id: start_id).first
+                return [] unless start_row
+
+                results = []
+                visited = Set.new([start_id])
+                queue   = [[start_id, 0, [start_id]]]
+
+                until queue.empty?
+                  current_id, depth, path = queue.shift
+                  neighbor_ids = associations_for(current_id)
+
+                  neighbor_ids.each do |nid|
+                    next if visited.include?(nid)
+
+                    neighbor_row = traces_ds
+                                   .where(trace_id: nid)
+                                   .where { strength >= min_strength }
+                                   .first
+                    next unless neighbor_row
+
+                    visited << nid
+                    neighbor_path = path + [nid]
+                    results << { trace_id: nid, depth: depth + 1, path: neighbor_path }
+                    queue << [nid, depth + 1, neighbor_path] if depth + 1 < max_hops
+                  end
+                end
+
+                results
+              rescue StandardError => e
+                log_warn("walk_associations failed: #{e.message}")
+                []
+              end
+
+              # Delete the N traces with the lowest confidence for a given type (quota enforcement).
+              def delete_lowest_confidence(trace_type:, count:)
+                return unless db_ready?
+
+                ids = traces_ds
+                      .where(trace_type: trace_type.to_s)
+                      .order(:confidence)
+                      .limit(count)
+                      .select_map(:trace_id)
+
+                ids.each { |tid| delete(tid) }
+              rescue StandardError => e
+                log_warn("delete_lowest_confidence failed: #{e.message}")
+              end
+
+              # Delete the N least-recently-used traces for a given type (quota enforcement).
+              def delete_least_recently_used(trace_type:, count:)
+                return unless db_ready?
+
+                ids = traces_ds
+                      .where(trace_type: trace_type.to_s)
+                      .order(:last_reinforced)
+                      .limit(count)
+                      .select_map(:trace_id)
+
+                ids.each { |tid| delete(tid) }
+              rescue StandardError => e
+                log_warn("delete_least_recently_used failed: #{e.message}")
+              end
+
+              # Convenience: retrieve firmware-type traces.
+              def firmware_traces
+                retrieve_by_type(:firmware)
+              end
+
+              # No-op — this store is write-through; nothing to flush.
+              def flush; end
+
+              # Returns true when both required tables exist in the connected DB.
+              def db_ready?
+                defined?(Legion::Data) &&
+                  Legion::Data.respond_to?(:connection) &&
+                  Legion::Data.connection&.table_exists?(TRACES_TABLE) &&
+                  Legion::Data.connection.table_exists?(ASSOCIATIONS_TABLE)
+              rescue StandardError
+                false
+              end
+
+              private
+
+              def db
+                Legion::Data.connection
+              end
+
+              # Dataset for memory_traces scoped by tenant_id (if set).
+              def traces_ds
+                ds = db[TRACES_TABLE]
+                @tenant_id ? ds.where(tenant_id: @tenant_id) : ds
+              end
+
+              def serialize_trace(trace)
+                payload = trace[:content_payload] || trace[:content]
+                tags    = trace[:domain_tags]
+                assocs  = trace[:associated_traces]
+                conf    = trace[:confidence]
+                ev      = trace[:emotional_valence]
+
+                {
+                  trace_id:                trace[:trace_id],
+                  tenant_id:               @tenant_id,
+                  trace_type:              trace[:trace_type].to_s,
+                  content:                 payload.is_a?(Hash) ? Legion::JSON.dump(payload) : payload.to_s,
+                  significance:            conf,
+                  confidence:              conf,
+                  associations:            assocs.is_a?(Array) ? Legion::JSON.dump(assocs) : '[]',
+                  domain_tags:             tags.is_a?(Array)   ? Legion::JSON.dump(tags)   : nil,
+                  strength:                trace[:strength],
+                  peak_strength:           trace[:peak_strength],
+                  base_decay_rate:         trace[:base_decay_rate],
+                  emotional_valence:       ev.is_a?(Numeric) ? ev.to_f : 0.0,
+                  emotional_intensity:     trace[:emotional_intensity],
+                  origin:                  trace[:origin].to_s,
+                  source_agent_id:         trace[:source_agent_id],
+                  storage_tier:            trace[:storage_tier].to_s,
+                  last_reinforced:         trace[:last_reinforced],
+                  last_decayed:            trace[:last_decayed],
+                  reinforcement_count:     trace[:reinforcement_count],
+                  unresolved:              trace[:unresolved]              || false,
+                  consolidation_candidate: trace[:consolidation_candidate] || false,
+                  parent_trace_id:         trace[:parent_trace_id],
+                  encryption_key_id:       trace[:encryption_key_id],
+                  partition_id:            trace[:partition_id],
+                  created_at:              trace[:created_at] || Time.now.utc,
+                  accessed_at:             Time.now.utc
+                }
+              end
+
+              def deserialize_trace(row)
+                content = parse_json_or_raw(row[:content])
+                {
+                  trace_id:                row[:trace_id],
+                  trace_type:              row[:trace_type]&.to_sym,
+                  content_payload:         content,
+                  content:                 content,
+                  strength:                row[:strength],
+                  peak_strength:           row[:peak_strength],
+                  base_decay_rate:         row[:base_decay_rate],
+                  emotional_valence:       row[:emotional_valence].to_f,
+                  emotional_intensity:     row[:emotional_intensity],
+                  domain_tags:             parse_json_array(row[:domain_tags]),
+                  origin:                  row[:origin]&.to_sym,
+                  source_agent_id:         row[:source_agent_id],
+                  created_at:              row[:created_at],
+                  last_reinforced:         row[:last_reinforced],
+                  last_decayed:            row[:last_decayed],
+                  reinforcement_count:     row[:reinforcement_count],
+                  confidence:              row[:confidence],
+                  storage_tier:            row[:storage_tier]&.to_sym,
+                  partition_id:            row[:partition_id],
+                  encryption_key_id:       row[:encryption_key_id],
+                  associated_traces:       parse_json_array(row[:associations]),
+                  parent_trace_id:         row[:parent_trace_id],
+                  child_trace_ids:         [],
+                  unresolved:              row[:unresolved]              || false,
+                  consolidation_candidate: row[:consolidation_candidate] || false
+                }
+              end
+
+              # Map keyword fields for partial updates, translating to DB column names.
+              def map_update_fields(fields)
+                mapping = {
+                  content_payload:   :content,
+                  associated_traces: :associations,
+                  parent_trace_id:   :parent_trace_id,
+                  child_trace_ids:   nil # not stored as a column
+                }
+
+                fields.each_with_object({}) do |(k, v), row|
+                  col = mapping.key?(k) ? mapping[k] : k
+                  next if col.nil?
+
+                  row[col] = case col
+                             when :content
+                               v.is_a?(Hash) ? Legion::JSON.dump(v) : v.to_s
+                             when :associations
+                               v.is_a?(Array) ? Legion::JSON.dump(v) : '[]'
+                             when :domain_tags
+                               v.is_a?(Array) ? Legion::JSON.dump(v) : nil
+                             when :trace_type, :origin, :storage_tier
+                               v.to_s
+                             else
+                               v
+                             end
+                end
+              end
+
+              def parse_json_or_raw(raw)
+                return raw unless raw.is_a?(String)
+
+                parsed = Legion::JSON.load(raw)
+                parsed.is_a?(Hash) ? parsed : raw
+              rescue StandardError
+                raw
+              end
+
+              def parse_json_array(raw)
+                return [] unless raw.is_a?(String)
+
+                result = Legion::JSON.load(raw)
+                result.is_a?(Array) ? result : []
+              rescue StandardError
+                []
+              end
+
+              def log_warn(message)
+                Legion::Logging.warn "[memory:postgres_store] #{message}" if defined?(Legion::Logging)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/memory/trace/runners/consolidation.rb

@@ -86,6 +86,13 @@ module Legion
                 { linked: true }
               end
 
+              def enforce_quota(store: nil, **)
+                store ||= default_store
+                quota = Quota.new
+                quota.enforce!(store)
+                { success: true, within_limits: quota.within_limits?(store) }
+              end
+
               def erase_by_type(type:, store: nil, **)
                 store ||= default_store
                 type = type.to_sym

data/lib/legion/extensions/agentic/memory/trace.rb

@@ -5,6 +5,7 @@ require 'legion/extensions/agentic/memory/trace/helpers/trace'
 require 'legion/extensions/agentic/memory/trace/helpers/decay'
 require 'legion/extensions/agentic/memory/trace/helpers/store'
 require 'legion/extensions/agentic/memory/trace/helpers/cache_store'
+require 'legion/extensions/agentic/memory/trace/helpers/postgres_store'
 require 'legion/extensions/agentic/memory/trace/helpers/error_tracer'
 require 'legion/extensions/agentic/memory/trace/runners/traces'
 require 'legion/extensions/agentic/memory/trace/runners/consolidation'
@@ -31,7 +32,10 @@ module Legion
             private
 
             def create_store
-              if defined?(Legion::Cache) && Legion::Cache.respond_to?(:connected?) && Legion::Cache.connected?
+              if postgres_available?
+                Legion::Logging.debug '[memory] Using shared PostgresStore (write-through)'
+                Helpers::PostgresStore.new(tenant_id: resolve_tenant_id)
+              elsif defined?(Legion::Cache) && Legion::Cache.respond_to?(:connected?) && Legion::Cache.connected?
                 Legion::Logging.debug '[memory] Using shared CacheStore (memcached)'
                 Helpers::CacheStore.new
               else
@@ -39,6 +43,23 @@ module Legion
                 Helpers::Store.new
               end
             end
+
+            def postgres_available?
+              defined?(Legion::Data) &&
+                Legion::Data.respond_to?(:connection) &&
+                Legion::Data.connection &&
+                %i[postgres mysql2].include?(Legion::Data.connection.adapter_scheme) &&
+                Legion::Data.connection.table_exists?(:memory_traces) &&
+                Legion::Data.connection.table_exists?(:memory_associations)
+            rescue StandardError
+              false
+            end
+
+            def resolve_tenant_id
+              Legion::Settings[:data]&.dig(:tenant_id)
+            rescue StandardError
+              nil
+            end
           end
         end
       end

data/lib/legion/extensions/agentic/memory/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.8'
+        VERSION = '0.1.11'
       end
     end
   end

data/spec/legion/extensions/agentic/memory/archaeology/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/archaeology/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Archaeology::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Archaeology::Runners::CognitiveArchaeology) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(120) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/compression/actors/maintenance_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/compression/actors/maintenance'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Compression::Actors::Maintenance do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Compression::Runners::CognitiveCompression) }
+  it { expect(actor.runner_function).to eq('compress_all') }
+  it { expect(actor.time).to eq(300) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/echo/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/echo/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Echo::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Echo::Runners::CognitiveEcho) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/echo_chamber/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/echo_chamber/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::EchoChamber::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::EchoChamber::Runners::CognitiveEchoChamber) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/immune_memory/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/immune_memory/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::ImmuneMemory::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::ImmuneMemory::Runners::CognitiveImmuneMemory) }
+  it { expect(actor.runner_function).to eq('decay_all') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/nostalgia/actors/maintenance_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/nostalgia/actors/maintenance'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Nostalgia::Actors::Maintenance do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Nostalgia::Runners::Recall) }
+  it { expect(actor.runner_function).to eq('age_memories') }
+  it { expect(actor.time).to eq(120) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/palimpsest/actors/decay_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/palimpsest/actors/decay'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Actors::Decay do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Palimpsest::Runners::CognitivePalimpsest) }
+  it { expect(actor.runner_function).to eq('decay_all_ghosts') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end

data/spec/legion/extensions/agentic/memory/reserve/actors/maintenance_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      class Every # rubocop:disable Lint/EmptyClass
+      end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+
+require 'legion/extensions/agentic/memory/reserve/actors/maintenance'
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Reserve::Actors::Maintenance do
+  subject(:actor) { described_class.new }
+
+  it { expect(actor.runner_class).to eq(Legion::Extensions::Agentic::Memory::Reserve::Runners::CognitiveReserve) }
+  it { expect(actor.runner_function).to eq('update_cognitive_reserve') }
+  it { expect(actor.time).to eq(60) }
+  it { expect(actor.use_runner?).to be false }
+  it { expect(actor.check_subtask?).to be false }
+  it { expect(actor.generate_task?).to be false }
+end