htm 0.0.20 → 0.0.30

data/lib/htm/long_term_memory/node_operations.rb

@@ -32,10 +32,10 @@ class HTM
         content_hash = HTM::Models::Node.generate_content_hash(content)
 
         # Wrap in transaction to ensure data consistency
-        ActiveRecord::Base.transaction do
+        HTM.db.transaction do
           # Check for existing node with same content (including soft-deleted)
           # This avoids unique constraint violations on content_hash
-          existing_node = HTM::Models::Node.with_deleted.find_by(content_hash: content_hash)
+          existing_node = HTM::Models::Node.with_deleted.first(content_hash: content_hash)
 
           # If found but soft-deleted, restore it
           if existing_node&.deleted?
@@ -48,7 +48,7 @@ class HTM
             robot_node = link_robot_to_node(robot_id: robot_id, node: existing_node)
 
             # Update the node's updated_at timestamp
-            existing_node.touch
+            existing_node.update(updated_at: Time.now)
 
             {
               node_id: existing_node.id,
@@ -65,7 +65,7 @@ class HTM
             end
 
             # Create new node
-            node = HTM::Models::Node.create!(
+            node = HTM::Models::Node.create(
               content: content,
               content_hash: content_hash,
               token_count: token_count,
@@ -97,19 +97,19 @@ class HTM
       # @return [HTM::Models::RobotNode] The robot_node link record
       #
       def link_robot_to_node(robot_id:, node:, working_memory: false)
-        robot_node = HTM::Models::RobotNode.find_by(robot_id: robot_id, node_id: node.id)
+        robot_node = HTM::Models::RobotNode.first(robot_id: robot_id, node_id: node.id)
 
         if robot_node
           # Existing link - record that robot remembered this again
           robot_node.record_remember!
-          robot_node.update!(working_memory: working_memory) if working_memory
+          robot_node.update(working_memory: working_memory) if working_memory
         else
           # New link
-          robot_node = HTM::Models::RobotNode.create!(
+          robot_node = HTM::Models::RobotNode.create(
             robot_id: robot_id,
             node_id: node.id,
-            first_remembered_at: Time.current,
-            last_remembered_at: Time.current,
+            first_remembered_at: Time.now,
+            last_remembered_at: Time.now,
             remember_count: 1,
             working_memory: working_memory
           )
@@ -127,17 +127,17 @@ class HTM
       # @return [Hash, nil] Node data or nil
       #
       def retrieve(node_id)
-        node = HTM::Models::Node.find_by(id: node_id)
+        node = HTM::Models::Node.first(id: node_id)
         return nil unless node
 
-        # Track access in a single UPDATE query (instead of separate increment! and touch)
-        node.update_columns(
-          access_count: node.access_count + 1,
-          last_accessed: Time.current
+        # Track access in a single UPDATE query (instead of separate operations)
+        node.this.update(
+          access_count: Sequel[:access_count] + 1,
+          last_accessed: Time.now
         )
 
         # Reload to get updated values
-        node.reload.attributes
+        node.refresh.to_hash
       end
 
       # Update last_accessed timestamp
@@ -146,8 +146,8 @@ class HTM
       # @return [void]
       #
       def update_last_accessed(node_id)
-        node = HTM::Models::Node.find_by(id: node_id)
-        node&.update(last_accessed: Time.current)
+        node = HTM::Models::Node.first(id: node_id)
+        node&.update(last_accessed: Time.now)
       end
 
       # Delete a node
@@ -156,8 +156,8 @@ class HTM
       # @return [void]
       #
       def delete(node_id)
-        node = HTM::Models::Node.find_by(id: node_id)
-        node&.destroy
+        node = HTM::Models::Node.first(id: node_id)
+        node&.delete
 
         # Selectively invalidate search-related cache entries only
         @cache&.invalidate_methods!(:search, :fulltext, :hybrid)
@@ -169,7 +169,7 @@ class HTM
       # @return [Boolean] True if node exists
       #
       def exists?(node_id)
-        HTM::Models::Node.exists?(node_id)
+        HTM::Models::Node.where(id: node_id).count > 0
       end
 
       # Mark nodes as evicted from working memory
@@ -186,7 +186,7 @@ class HTM
 
         HTM::Models::RobotNode
           .where(robot_id: robot_id, node_id: node_ids)
-          .update_all(working_memory: false)
+          .update(working_memory: false)
       end
 
       # Track access for multiple nodes (bulk operation)
@@ -200,8 +200,9 @@ class HTM
         return if node_ids.empty?
 
         # Atomic batch update
-        HTM::Models::Node.where(id: node_ids).update_all(
-          "access_count = access_count + 1, last_accessed = NOW()"
+        HTM::Models::Node.where(id: node_ids).update(
+          access_count: Sequel[:access_count] + 1,
+          last_accessed: Sequel.lit('NOW()')
         )
       end
     end

data/lib/htm/long_term_memory/relevance_scorer.rb

@@ -114,7 +114,7 @@ class HTM
           # Full-text search (returns hashes directly)
           search_fulltext_uncached(timeframe: timeframe, query: query, limit: limit * 2, metadata: metadata)
         else
-          # Time-range only - use raw SQL to avoid ActiveRecord object instantiation
+          # Time-range only - use raw SQL to avoid ORM object instantiation
           # This is more efficient than .map(&:attributes) which creates intermediate objects
           fetch_candidates_by_timeframe(timeframe: timeframe, metadata: metadata, limit: limit * 2)
         end
@@ -146,7 +146,7 @@ class HTM
           .take(limit)
       end
 
-      # Fetch candidates by timeframe using raw SQL (avoids ActiveRecord overhead)
+      # Fetch candidates by timeframe using raw SQL (avoids ORM overhead)
       #
       # @param timeframe [nil, Range, Array<Range>] Time range(s) to search
       # @param metadata [Hash] Filter by metadata fields
@@ -169,10 +169,7 @@ class HTM
           LIMIT ?
         SQL
 
-        result = ActiveRecord::Base.connection.select_all(
-          ActiveRecord::Base.sanitize_sql_array([sql, limit])
-        )
-        result.to_a
+        HTM.db.fetch(sql, limit).all.map { |r| r.transform_keys(&:to_s) }
       end
 
       # Search nodes by tags
@@ -188,30 +185,36 @@ class HTM
 
         # Build base query with specific columns to avoid loading unnecessary data
         query = HTM::Models::Node
-          .select('nodes.id, nodes.content, nodes.access_count, nodes.created_at, nodes.token_count')
-          .joins(:tags)
-          .where(tags: { name: tags })
+          .select(
+            Sequel[:nodes][:id],
+            Sequel[:nodes][:content],
+            Sequel[:nodes][:access_count],
+            Sequel[:nodes][:created_at],
+            Sequel[:nodes][:token_count]
+          )
+          .join(:node_tags, node_id: :id)
+          .join(:tags, id: Sequel[:node_tags][:tag_id])
+          .where(Sequel[:tags][:name] => tags)
           .distinct
 
         # Apply timeframe filter if provided
-        query = query.where(created_at: timeframe) if timeframe
+        query = query.where(Sequel[:nodes][:created_at] => timeframe) if timeframe
 
         if match_all
           # Match ALL tags (intersection)
           query = query
-            .group('nodes.id')
-            .having('COUNT(DISTINCT tags.name) = ?', tags.size)
+            .group(Sequel[:nodes][:id])
+            .having { Sequel.function(:count, Sequel[:tags][:name].distinct) =~ tags.size }
         end
 
-        # Convert to hashes efficiently using pluck-style approach
-        # This avoids instantiating full ActiveRecord objects
-        nodes = query.limit(limit).map do |node|
+        # Fetch and convert to hashes with string keys
+        nodes = query.limit(limit).all.map do |row|
           {
-            'id' => node.id,
-            'content' => node.content,
-            'access_count' => node.access_count,
-            'created_at' => node.created_at,
-            'token_count' => node.token_count
+            'id' => row[:id],
+            'content' => row[:content],
+            'access_count' => row[:access_count],
+            'created_at' => row[:created_at],
+            'token_count' => row[:token_count]
           }
         end
 

data/lib/htm/long_term_memory/robot_operations.rb

@@ -15,8 +15,8 @@ class HTM
       # @return [Integer] Robot ID
       #
       def register_robot(robot_name)
-        robot = HTM::Models::Robot.find_or_create_by(name: robot_name)
-        robot.update(last_active: Time.current)
+        robot = HTM::Models::Robot.find_or_create(name: robot_name)
+        robot.update(last_active: Time.now)
         robot.id
       end
 
@@ -26,8 +26,8 @@ class HTM
       # @return [void]
       #
       def update_robot_activity(robot_id)
-        robot = HTM::Models::Robot.find_by(id: robot_id)
-        robot&.update(last_active: Time.current)
+        robot = HTM::Models::Robot.first(id: robot_id)
+        robot&.update(last_active: Time.now)
       end
     end
   end

data/lib/htm/long_term_memory/tag_operations.rb

@@ -36,20 +36,31 @@ class HTM
         attr_accessor :popular_tags_cache, :popular_tags_cache_expires_at, :popular_tags_mutex
       end
 
-      # Add a tag to a node
+      # Add a tag to a node (creates tag and all parent tags)
+      #
+      # When adding a hierarchical tag like "database:postgresql:extensions",
+      # this also creates and associates the parent tags "database" and
+      # "database:postgresql" with the node.
       #
       # @param node_id [Integer] Node database ID
       # @param tag [String] Tag name
       # @return [void]
       #
+      # @example
+      #   add_tag(node_id: 123, tag: "database:postgresql:extensions")
+      #   # Creates tags: "database", "database:postgresql", "database:postgresql:extensions"
+      #   # Associates all three with node 123
+      #
       def add_tag(node_id:, tag:)
-        tag_record = HTM::Models::Tag.find_or_create_by(name: tag)
-        HTM::Models::NodeTag.create(
-          node_id: node_id,
-          tag_id: tag_record.id
-        )
-      rescue ActiveRecord::RecordNotUnique
-        # Tag association already exists, ignore
+        # Create tag and all ancestor tags, then associate each with the node
+        HTM::Models::Tag.find_or_create_with_ancestors(tag).each do |tag_record|
+          HTM::Models::NodeTag.find_or_create(
+            node_id: node_id,
+            tag_id: tag_record.id
+          )
+        rescue Sequel::UniqueConstraintViolation
+          # Tag association already exists, ignore
+        end
       end
 
       # Retrieve nodes by ontological topic
@@ -70,34 +81,48 @@ class HTM
         # Enforce limit to prevent DoS
         safe_limit = [[limit.to_i, 1].max, MAX_TAG_QUERY_LIMIT].min
 
+        # Build base query with joins
+        # Use subquery with DISTINCT ON to get unique nodes by id
         if exact
-          nodes = HTM::Models::Node
-            .joins(:tags)
-            .where(tags: { name: topic_path })
+          node_ids = HTM::Models::Node
+            .select(Sequel[:nodes][:id])
+            .join(:node_tags, node_id: :id)
+            .join(:tags, id: Sequel[:node_tags][:tag_id])
+            .where(Sequel[:tags][:name] => topic_path)
             .distinct
-            .order(created_at: :desc)
-            .limit(safe_limit)
+            .select_map(Sequel[:nodes][:id])
         elsif fuzzy
           # Trigram similarity search - tolerates typos and partial matches
           safe_similarity = [[min_similarity.to_f, 0.0].max, 1.0].min
-          nodes = HTM::Models::Node
-            .joins(:tags)
-            .where("similarity(tags.name, ?) >= ?", topic_path, safe_similarity)
+          node_ids = HTM::Models::Node
+            .select(Sequel[:nodes][:id])
+            .join(:node_tags, node_id: :id)
+            .join(:tags, id: Sequel[:node_tags][:tag_id])
+            .where(Sequel.lit("similarity(tags.name, ?) >= ?", topic_path, safe_similarity))
             .distinct
-            .order(created_at: :desc)
-            .limit(safe_limit)
+            .select_map(Sequel[:nodes][:id])
         else
           # Sanitize LIKE pattern to prevent wildcard injection
           safe_pattern = HTM::SqlBuilder.sanitize_like_pattern(topic_path)
-          nodes = HTM::Models::Node
-            .joins(:tags)
-            .where("tags.name LIKE ?", "#{safe_pattern}%")
+          node_ids = HTM::Models::Node
+            .select(Sequel[:nodes][:id])
+            .join(:node_tags, node_id: :id)
+            .join(:tags, id: Sequel[:node_tags][:tag_id])
+            .where(Sequel.like(Sequel[:tags][:name], "#{safe_pattern}%"))
             .distinct
-            .order(created_at: :desc)
-            .limit(safe_limit)
+            .select_map(Sequel[:nodes][:id])
         end
 
-        nodes.map(&:attributes)
+        # Return empty array if no node_ids found
+        return [] if node_ids.empty?
+
+        # Fetch full node records for the matching ids
+        HTM::Models::Node
+          .where(id: node_ids)
+          .order(Sequel.desc(:created_at))
+          .limit(safe_limit)
+          .all
+          .map(&:to_hash)
       end
 
       # Get ontology structure view
@@ -105,10 +130,9 @@ class HTM
       # @return [Array<Hash>] Ontology structure
       #
       def ontology_structure
-        result = ActiveRecord::Base.connection.select_all(
+        HTM.db.fetch(
           "SELECT * FROM ontology_structure WHERE root_topic IS NOT NULL ORDER BY root_topic, level1_topic, level2_topic"
-        )
-        result.to_a
+        ).all.map { |r| r.transform_keys(&:to_s) }
       end
 
       # Get topic relationships (co-occurrence)
@@ -122,7 +146,6 @@ class HTM
         safe_limit = [[limit.to_i, 1].max, MAX_TAG_QUERY_LIMIT].min
         safe_min = [min_shared_nodes.to_i, 1].max
 
-        # Use parameterized query to prevent SQL injection
         sql = <<~SQL
           SELECT t1.name AS topic1, t2.name AS topic2, COUNT(DISTINCT nt1.node_id) AS shared_nodes
           FROM tags t1
@@ -131,17 +154,12 @@ class HTM
           JOIN tags t2 ON nt2.tag_id = t2.id
           WHERE t1.name < t2.name
           GROUP BY t1.name, t2.name
-          HAVING COUNT(DISTINCT nt1.node_id) >= $1
+          HAVING COUNT(DISTINCT nt1.node_id) >= ?
           ORDER BY shared_nodes DESC
-          LIMIT $2
+          LIMIT ?
         SQL
 
-        result = ActiveRecord::Base.connection.exec_query(
-          sql,
-          'topic_relationships',
-          [[nil, safe_min], [nil, safe_limit]]
-        )
-        result.to_a
+        HTM.db.fetch(sql, safe_min, safe_limit).all.map { |r| r.transform_keys(&:to_s) }
       end
 
       # Get topics for a specific node
@@ -151,10 +169,10 @@ class HTM
       #
       def node_topics(node_id)
         HTM::Models::Tag
-          .joins(:node_tags)
-          .where(node_tags: { node_id: node_id })
+          .join(:node_tags, tag_id: :id)
+          .where(Sequel[:node_tags][:node_id] => node_id)
           .order(:name)
-          .pluck(:name)
+          .select_map(:name)
       end
 
       # Get tags for a specific node
@@ -164,10 +182,10 @@ class HTM
       #
       def get_node_tags(node_id)
         HTM::Models::Tag
-          .joins(:node_tags)
-          .where(node_tags: { node_id: node_id })
-          .pluck(:name)
-      rescue ActiveRecord::ActiveRecordError => e
+          .join(:node_tags, tag_id: :id)
+          .where(Sequel[:node_tags][:node_id] => node_id)
+          .select_map(:name)
+      rescue Sequel::Error => e
         HTM.logger.error("Failed to retrieve tags for node #{node_id}: #{e.message}")
         []
       end
@@ -182,13 +200,13 @@ class HTM
 
         # Single query to get all tags for all nodes
         results = HTM::Models::NodeTag
-          .joins(:tag)
+          .join(:tags, id: :tag_id)
           .where(node_id: node_ids)
-          .pluck(:node_id, 'tags.name')
+          .select_map([:node_id, Sequel[:tags][:name]])
 
         # Group by node_id
         results.group_by(&:first).transform_values { |pairs| pairs.map(&:last) }
-      rescue ActiveRecord::ActiveRecordError => e
+      rescue Sequel::Error => e
         HTM.logger.error("Failed to batch load tags: #{e.message}")
         {}
       end
@@ -204,17 +222,21 @@ class HTM
         safe_limit = [[limit.to_i, 1].max, MAX_TAG_QUERY_LIMIT].min
 
         query = HTM::Models::Tag
-          .joins(:node_tags)
-          .joins('INNER JOIN nodes ON nodes.id = node_tags.node_id')
-          .group('tags.id', 'tags.name')
-          .select('tags.name, COUNT(node_tags.id) as usage_count')
-
-        query = query.where('nodes.created_at >= ? AND nodes.created_at <= ?', timeframe.begin, timeframe.end) if timeframe
+          .join(:node_tags, tag_id: :id)
+          .join(:nodes, id: Sequel[:node_tags][:node_id])
+          .group(Sequel[:tags][:id], Sequel[:tags][:name])
+          .select(Sequel[:tags][:name], Sequel.function(:count, Sequel[:node_tags][:id]).as(:usage_count))
+
+        if timeframe
+          query = query.where(Sequel[:nodes][:created_at] >= timeframe.begin)
+            .where(Sequel[:nodes][:created_at] <= timeframe.end)
+        end
 
         query
-          .order('usage_count DESC')
+          .order(Sequel.desc(:usage_count))
           .limit(safe_limit)
-          .map { |tag| { name: tag.name, usage_count: tag.usage_count } }
+          .all
+          .map { |tag| { name: tag[:name], usage_count: tag[:usage_count].to_i } }
       end
 
       # Fuzzy search for tags using trigram similarity
@@ -243,12 +265,10 @@ class HTM
           LIMIT ?
         SQL
 
-        result = ActiveRecord::Base.connection.select_all(
-          ActiveRecord::Base.sanitize_sql_array([sql, query, query, safe_similarity, safe_limit])
-        )
-
-        result.map { |r| { name: r['name'], similarity: r['similarity'].to_f } }
-      rescue ActiveRecord::ActiveRecordError => e
+        HTM.db.fetch(sql, query, query, safe_similarity, safe_limit)
+          .all
+          .map { |r| { name: r[:name], similarity: r[:similarity].to_f } }
+      rescue Sequel::Error => e
         HTM.logger.error("Failed to search tags: #{e.message}")
         []
       end
@@ -353,6 +373,7 @@ class HTM
         params = []
 
         # Exact matches (highest priority)
+        # Use Sequel.lit with ? placeholders for proper parameter binding
         if exact_candidates.any?
           placeholders = exact_candidates.map { '?' }.join(', ')
           conditions << "(SELECT name, 1 as priority FROM tags WHERE name IN (#{placeholders}))"
@@ -367,19 +388,13 @@ class HTM
         end
 
         # Component matches
-        # Pre-sanitize components once to avoid duplicate processing
         if component_candidates.any?
-          # Pre-compute sanitized components for efficiency
-          sanitized_components = component_candidates.map do |component|
-            [component, HTM::SqlBuilder.sanitize_like_pattern(component)]
-          end
-
-          component_conditions = sanitized_components.map do |_component, _safe|
-            # Match: exact, starts with, ends with, or middle
+          component_conditions = component_candidates.map do |_|
             "(name = ? OR name LIKE ? OR name LIKE ? OR name LIKE ?)"
           end
 
-          component_params = sanitized_components.flat_map do |component, safe_component|
+          component_params = component_candidates.flat_map do |component|
+            safe_component = HTM::SqlBuilder.sanitize_like_pattern(component)
             [
               component,                 # exact match
               "#{safe_component}:%",     # starts with
@@ -393,10 +408,11 @@ class HTM
         end
 
         # Trigram fuzzy matches (lowest priority - fallback for typos)
-        # Uses pg_trgm similarity to find tags even with spelling errors
         if fuzzy_fallback && component_candidates.any?
           safe_similarity = [[min_similarity.to_f, 0.0].max, 1.0].min
-          trigram_conditions = component_candidates.map { "similarity(name, ?) >= ?" }
+          trigram_conditions = component_candidates.map do |_|
+            "similarity(name, ?) >= ?"
+          end
           trigram_params = component_candidates.flat_map { |c| [c, safe_similarity] }
 
           conditions << "(SELECT name, 4 as priority FROM tags WHERE #{trigram_conditions.join(' OR ')})"
@@ -406,6 +422,8 @@ class HTM
         return [] if conditions.empty?
 
         # Combine with UNION and order by priority
+        params << MAX_TAG_QUERY_LIMIT
+
         sql = <<~SQL
           SELECT DISTINCT name FROM (
             #{conditions.join(' UNION ')}
@@ -413,13 +431,9 @@ class HTM
           ORDER BY name
           LIMIT ?
         SQL
-        params << MAX_TAG_QUERY_LIMIT
 
-        result = ActiveRecord::Base.connection.select_all(
-          ActiveRecord::Base.sanitize_sql_array([sql, *params])
-        )
-        result.map { |r| r['name'] }
-      rescue ActiveRecord::ActiveRecordError => e
+        HTM.db.fetch(sql, *params).all.map { |r| r[:name] }
+      rescue Sequel::Error => e
         HTM.logger.error("Failed to find matching tags: #{e.message}")
         []
       end

data/lib/htm/long_term_memory/vector_search.rb

@@ -94,15 +94,14 @@ class HTM
           LIMIT ?
         SQL
 
-        result = ActiveRecord::Base.connection.select_all(
-          ActiveRecord::Base.sanitize_sql_array([sql, embedding_str, embedding_str, limit])
-        )
+        result = HTM.db.fetch(sql, embedding_str, embedding_str, limit).all
 
         # Track access for retrieved nodes
-        node_ids = result.map { |r| r['id'] }
+        node_ids = result.map { |r| r[:id] }
         track_access(node_ids)
 
-        result.to_a
+        # Convert to hash with string keys for compatibility
+        result.map { |r| r.transform_keys(&:to_s) }
       end
     end
   end

data/lib/htm/long_term_memory.rb

@@ -17,7 +17,7 @@ require_relative 'long_term_memory/fulltext_search'
 require_relative 'long_term_memory/hybrid_search'
 
 class HTM
-  # Long-term Memory - PostgreSQL/TimescaleDB-backed permanent storage
+  # Long-term Memory - PostgreSQL-backed permanent storage
   #
   # LongTermMemory provides durable storage for all memory nodes with:
   # - Vector similarity search (RAG)
@@ -25,7 +25,7 @@ class HTM
   # - Time-range queries
   # - Relationship graphs
   # - Tag system
-  # - ActiveRecord ORM for data access
+  # - Sequel ORM for data access
   # - Query result caching for efficiency
   #
   # This class uses standalone utility classes and modules:
@@ -72,7 +72,7 @@ class HTM
     # Initialize long-term memory storage
     #
     # @param config [Hash] Database configuration (host, port, dbname, user, password)
-    # @param pool_size [Integer, nil] Connection pool size (uses ActiveRecord default if nil)
+    # @param pool_size [Integer, nil] Connection pool size (uses Sequel default if nil)
     # @param query_timeout [Integer] Query timeout in milliseconds (default: 30000)
     # @param cache_size [Integer] Number of query results to cache (default: 1000, use 0 to disable)
     # @param cache_ttl [Integer] Cache time-to-live in seconds (default: 300)
@@ -90,8 +90,8 @@ class HTM
       @config = config
       @query_timeout = query_timeout  # in milliseconds
 
-      # Set statement timeout for ActiveRecord queries
-      ActiveRecord::Base.connection.execute("SET statement_timeout = #{@query_timeout}")
+      # Set statement timeout for Sequel queries
+      HTM.db.run("SET statement_timeout = #{@query_timeout}")
 
       # Initialize query result cache (disable with cache_size: 0)
       @cache = HTM::QueryCache.new(size: cache_size, ttl: cache_ttl)
@@ -104,13 +104,13 @@ class HTM
     def stats
       base_stats = {
         total_nodes: HTM::Models::Node.count,
-        nodes_by_robot: HTM::Models::RobotNode.group(:robot_id).count,
+        nodes_by_robot: HTM::Models::RobotNode.group_and_count(:robot_id).as_hash(:robot_id, :count),
         total_tags: HTM::Models::Tag.count,
-        oldest_memory: HTM::Models::Node.minimum(:created_at),
-        newest_memory: HTM::Models::Node.maximum(:created_at),
+        oldest_memory: HTM::Models::Node.min(:created_at),
+        newest_memory: HTM::Models::Node.max(:created_at),
         active_robots: HTM::Models::Robot.count,
-        robot_activity: HTM::Models::Robot.select(:id, :name, :last_active).map(&:attributes),
-        database_size: ActiveRecord::Base.connection.select_value("SELECT pg_database_size(current_database())").to_i
+        robot_activity: HTM::Models::Robot.select(:id, :name, :last_active).all.map(&:values),
+        database_size: HTM.db.get(Sequel.function(:pg_database_size, Sequel.function(:current_database))).to_i
       }
 
       # Include cache statistics if cache is enabled
@@ -121,9 +121,9 @@ class HTM
       base_stats
     end
 
-    # Shutdown - no-op with ActiveRecord (connection pool managed by ActiveRecord)
+    # Shutdown - no-op with Sequel (connection pool managed by Sequel)
     def shutdown
-      # ActiveRecord handles connection pool shutdown
+      # Sequel handles connection pool shutdown
       # This method kept for API compatibility
     end
 
@@ -137,7 +137,7 @@ class HTM
 
     # For backwards compatibility with tests/code that expect pool_size
     def pool_size
-      ActiveRecord::Base.connection_pool.size
+      HTM.db.pool.size
     end
   end
 end