agent99 0.0.3 → 0.0.5

data/README.md

@@ -1,62 +1,102 @@
-# Agent99 Framework (AFW)
-
-**Under Development**  Initial release has no AI components - its just a generic client-server / request-response micro-services system using a peer-to-peer messaging broker and a centralized agent registry.  To keep up with the version changes review [The Changelog](./CHANGELOG.md) file.
-
-Agent99 is a Ruby-based framework for building and managing AI agents in a distributed system. It provides a robust foundation for creating intelligent agents that can communicate, discover each other, and perform various tasks.
-
-## Hype!
-
-🌟 **Introducing Agent99**: Your Friendly Ruby Sidekick for Building Intelligent Software Agents! 🌟
-
-Do you ever miss the charm and wit of Barbara Feldon's iconic character from *Get Smart*? Just as Agent 99 was always ready to tackle mischief and save the day, **Agent99** is here to help you create your very own software agents that can communicate, collaborate, and conquer tasks in a smart and efficient way!
-
-### Why Choose Agent99?
-
-🔍 **Independent Agents, Unified Communication**: Say goodbye to complex service orchestration! Agent99 empowers you to build micro-services that communicate seamlessly through a robust peer-to-peer messaging network. Each agent operates independently while working together like a well-oiled machine!
-
-🤖 **Smart Automation for the Modern Age**: In the era of AI, why settle for less? With Agent99, you can develop software agents that respond intelligently to incoming requests—just like a secret agent reacting to their next mission! Deploy your own digital spies to gather data, complete tasks, and more.
-
-📦 **Quick Setup & Easy Integration**: Just like Agent 99’s quick thinking, our library is designed for rapid development. Get up and running in no time, whether you’re building a small project or an enterprise-level solution!
-
-
-### Features that Make Agent99 a Must-Have:
-
-- 🌐 **Peer-to-Peer Messaging**: Ensure that your agents can communicate effortlessly, just like Agent 99 and Max.
-- 🚀 **Agile Development**: Design and deploy agents at lightning speed, giving you the freedom to innovate.
-- 🔒 **Secure Communication**: Built with security in mind, because even our agents deserve to keep their secrets safe.
-- 📊 **Scalability**: Expand your network of agents as your needs grow—no mission is too big!
-
-### Get Smart! Join the Revolution!
-
-Whether you’re a seasoned Ruby developer or just getting started, Agent99 provides the tools you need to build your very own quirky, intelligent agents. Just like Agent 99, your agents will be clever, adaptable, and ready to tackle any challenge!
-
-### How to Get Started:
+# Agent99
+<br/>
+
+> [!CAUTION]
+> ## ⚠️ Under Development ⚠️
+> Initial release has no AI components - it's a generic client-server / request-response micro-services system using peer-to-peer messaging and centralized agent registry. Review [The Changelog](./CHANGELOG.md) for version changes.
+<br /><br />
+
+<div align="center">
+  <table>
+    <tr>
+      <td width="40%" align="center" valign="top">
+        <img src="docs/assets/images/agent99_logo.png" alt="Agent99 - Ruby Framework for Intelligent Software Agents" width="1200">
+        <br /><br />
+        [Comprehensive Documentation Website](https://madbomber.github.io/agent99/)
+      </td>
+      <td width="60%" align="left" valign="top">
+        Agent99 is a Ruby-based framework for building and managing intelligent software agents in a distributed system. Like the clever Agent 99 from Get Smart, your agents will be smart, adaptable, and ready to tackle any challenge through seamless peer-to-peer communication and centralized discovery.
+        <br/><br/>
+        <h3>Key Features</h3>
+        <ul>
+            <li><strong>🌐 <a href="#agent-discovery">Agent Discovery</a></strong> - Find agents by capabilities</li>
+            <li><strong>📡 <a href="#flexible-communication">Peer-to-Peer Messaging</a></strong> - AMQP & NATS support</li>
+            <li><strong>🔄 <a href="#message-processing">Message Processing</a></strong> - Requests, responses & control</li>
+            <li><strong>📋 <a href="#registry-integration">Registry Integration</a></strong> - Centralized agent registry</li>
+            <li><strong>⚡ <a href="#control-actions">Control Actions</a></strong> - Pause, resume, update agents</li>
+            <li><strong>🔧 <a href="#agent-lifecycle-management">Lifecycle Management</a></strong> - Easy setup & teardown</li>
+            <li><strong>🚀 <a href="#multi-agent-processing">Multi-Agent Processing</a></strong> - Thread isolation support</li>
+            <li><strong>📊 <a href="#error-handling-and-logging">Error Handling & Logging</a></strong> - Built-in management</li>
+        </ul>
+      </td>
+    </tr>
+  </table>
+</div>
+
+## Table of Contents
+
+* [Quick Start](#quick-start)
+* [Prerequisites](#prerequisites)
+* [Architecture Overview](#architecture-overview)
+* [Installation](#installation)
+* [Usage](#usage)
+* [Configuration](#configuration)
+* [Agent Lifecycle](#agent-lifecycle)
+* [Message Processing](#message-processing)
+* [Registry Integration](#registry-integration)
+* [Examples](#examples)
+* [Evolving Standards](#evolving-standards)
+* [Contributing](#contributing)
+* [Roadmap](#roadmap)
+* [License](#license)
+
+## Quick Start
+
+Jump right in with our step-by-step guide:
+
+1. **Prerequisites**: [Install message broker](#prerequisites) (NATS or RabbitMQ)
+2. **Install Agent99**: Add to Gemfile and bundle install
+3. **Start Registry**: Launch the central agent registry
+4. **Create Your First Agent**: Build a simple greeter agent
+5. **Test Communication**: Verify agents can discover and communicate
+
+📖 **Detailed walkthrough**: [Getting Started Guide](docs/getting-started/quick-start.md)
+
+## Prerequisites
+
+Agent99 requires a message broker for inter-agent communication. Choose one:
+
+### NATS (Recommended)
+```bash
+# macOS
+brew install nats-server
+
+# Start NATS
+nats-server
+```
 
-1. **Install**: Simply add Agent99 to your Gemfile and run `bundle install`.
-2. **Create an Agent**: Use our simple API to define and deploy your first agent.
-3. **Watch Them Work**: Sit back and relax as your agents spring into action, communicating with one another to accomplish tasks that would impress even the chief of CONTROL!
+### RabbitMQ  
+```bash
+# macOS
+brew install rabbitmq
 
-### Spread the Word!
+# Start RabbitMQ
+brew services start rabbitmq
+```
 
-**Join the Agent99 community** on GitHub and share your experiences, tips, and feedback. Let’s build a world of smart agents together! And remember, just like Agent 99 always had Max’s back, we’ve got yours during your development journey.
+📋 **More installation options**: [Installation Guide](docs/getting-started/installation.md)
 
-🕵️‍♂️ **Become an Agent!** Dive into the world of Agent99 today: [GitHub Repository](#) 📖
+## Architecture Overview
 
-**Agent99** – Because when it comes to building software agents, it's all about being smart!
+![Agent99 Architecture](docs/assets/images/agent99-architecture.svg)
 
-... end of the Hype; now back to normal.
+Agent99 follows a distributed architecture with three core components:
 
-## Features
+- **🏛️ Central Registry**: Service discovery and agent registration
+- **📡 Message Broker**: Peer-to-peer communication backbone (NATS/AMQP)
+- **🤖 Agents**: Independent services with specific capabilities
 
-- Agent Lifecycle Management: Easy setup and teardown of agents
-- Message Processing: Handle requests, responses, and control messages
-- Agent Discovery: Find other agents based on capabilities
-- Flexible Communication: Support for both AMQP and NATS messaging systems
-- Registry Integration: Register and discover agents through a central registry
-- Error Handling and Logging: Built-in error management and logging capabilities
-- Control Actions: Pause, resume, update configuration, and request status of agents
-- Dynamic Agent Loading: Support for runtime loading and deployment of new agents
-- Multi-Agent Processing: Run multiple agents within the same process using thread isolation
+📚 **Deep dive**: [Architecture Documentation](docs/core-concepts/architecture.md)
 
 ## Installation
 
@@ -80,63 +120,151 @@ $ gem install agent99
 
 ## Usage
 
-Here's a basic example of how to create an AI agent:
+Create your first agent in three simple steps:
 
+### 1. Define Request Schema
 ```ruby
-require 'agent99'
-
-class MyAgentRequest < SimpleJsonSchemaBuilder::Base
+class GreeterRequest < SimpleJsonSchemaBuilder::Base
   object do
     object :header, schema: Agent99::HeaderSchema
-
-    # Define your agents parameters ....
-    string :greeting, required: false,  examples: ["Hello"]
-    string :name,     required: true,   examples: ["World"]
+    string :name, required: true, examples: ["World"]
   end
 end
+```
 
-class MyAgent < Agent99::Base
-  REQUEST_SCHEMA  = MyAgentRequest.schema
-
-  def capabilities
-    ['text_processing', 'sentiment_analysis']
-    # TODO: make up mind on keyword or unstructured text
-  end
-
-  def receive_request
-    # Handle the validated incoming requests
-    response = { result: "Processed request" }
-
-    # Not every request needs a response
-    send_response(response)
+### 2. Implement Agent Class
+```ruby
+class GreeterAgent < Agent99::Base
+  def info
+    {
+      name: self.class.to_s,
+      type: :server,
+      capabilities: ['greeter', 'hello_world'],
+      request_schema: GreeterRequest.schema
+    }
   end
 
-  def receive_response
-    # You sent a request to another agent
-    # now handle the response.
+  def process_request(payload)
+    name = payload.dig(:name)
+    send_response(result: "Hello, #{name}!")
   end
 end
+```
 
-agent = MyAgent.new
+### 3. Run Your Agent
+```ruby
+require 'agent99'
+agent = GreeterAgent.new
 agent.run
 ```
 
+🎯 **More examples**: [Usage Examples](docs/examples/)
+
 ## Configuration
 
-The framework can be configured through environment variables:
+Configure Agent99 through environment variables:
+
+### Core Settings
+- `AGENT99_REGISTRY_URL`: Registry service URL (default: `http://localhost:4567`)
+- `AGENT99_LOG_LEVEL`: Logging verbosity (default: `INFO`)
+
+### NATS Configuration
+- `NATS_URL`: NATS server URL (default: `nats://localhost:4222`)
+- `NATS_USER`: Username for authentication
+- `NATS_PASS`: Password for authentication
+
+### AMQP/RabbitMQ Configuration
+- `RABBITMQ_URL`: RabbitMQ server URL (default: `amqp://localhost:5672`)
+- `RABBITMQ_USER`: Username (default: `guest`)
+- `RABBITMQ_PASS`: Password (default: `guest`)
+
+📚 **Complete configuration guide**: [Configuration Documentation](docs/configuration/)
+
+## Agent Lifecycle
+
+![Agent Lifecycle](docs/assets/images/agent-lifecycle.svg)
+
+Agent99 manages the complete lifecycle of your agents:
+
+- **🎬 Initialization**: Agent registers with the central registry
+- **⚡ Running**: Agent processes requests and sends responses
+- **⏸️ Paused**: Agent temporarily stops processing (control action)
+- **🔄 Updated**: Agent receives new configuration or capabilities
+- **🛑 Shutdown**: Agent gracefully disconnects and cleans up
+
+🔄 **Detailed lifecycle management**: [Agent Lifecycle Guide](docs/core-concepts/agent-lifecycle.md)
+
+## Message Processing
+
+![Message Processing Flow](docs/assets/images/message-processing-flow.svg)
+
+Agent99 handles three types of messages:
+
+- **📨 Requests**: Incoming work for agents to process
+- **📤 Responses**: Results sent back to requesters
+- **🎛️ Control**: Management commands (pause, resume, update)
+
+Each message is validated, routed, and processed with full error handling and logging.
+
+⚙️ **Message processing details**: [Message Processing Guide](docs/framework-components/message-processing.md)
+
+## Registry Integration
+
+![Agent Registry Process](docs/assets/images/agent-registry-processes.svg)
+
+The central registry enables dynamic service discovery:
+
+1. **📝 Registration**: Agents announce their capabilities
+2. **🔍 Discovery**: Find agents by capability or name
+3. **📋 Management**: Monitor and control registered agents
+4. **🚪 Withdrawal**: Clean removal from registry
+
+The registry supports both HTTP REST API and direct client integration.
+
+🏛️ **Registry implementation**: [Registry Documentation](docs/framework-components/agent-registry.md)
+
+## Examples
+
+Explore real-world implementations:
+
+- **🚀 [Demo Runner](examples/run_demo.rb)**: Complete working system
+- **👋 [Greeter Agent](examples/greeter_agent.rb)**: Simple request-response
+- **🔄 [Multi-Agent System](examples/multi_agent/)**: Coordinated agents
+- **📊 [Monitoring Dashboard](examples/dashboard/)**: Agent status monitoring
+
+💡 **All examples**: [Examples Directory](docs/examples/)
+
+## Evolving Standards
+
+- [agntcy.org](https://agntcy.org) - Agency protocol initiative
+- [Agent2Agent](https://a2a-protocol.org/latest/) - Linux Foundation protocol
 
-- `REGISTRY_BASE_URL`: URL of the agent registry service (default: 'http://localhost:4567')  See the default registry service in the examples folder.
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/MadBomber/agent99.
 
-## Short-term Roadmap
+## Roadmap
+
+### Short-term (v0.1.x)
+- **🔍 Enhanced Discovery**: Semantic search with vector database (SQLite + embeddings)
+- **📋 Schema Validation**: Complete request/response schema definitions
+- **🤖 AI Integration**: RAG-enabled agents using prompts as tools
+- **📊 Monitoring**: Built-in metrics and health checks
+
+### Medium-term (v0.2.x)
+- **🔐 Security**: Authentication and authorization framework
+- **⚡ Performance**: Connection pooling and message batching
+- **🌍 Multi-broker**: Support for multiple message brokers simultaneously
+- **📈 Scaling**: Load balancing and auto-scaling capabilities
+
+### Long-term (v1.0+)
+- **🧠 Intelligence**: Built-in ML/AI capabilities
+- **🔗 Interoperability**: Full Agent2Agent protocol compliance
+- **☁️ Cloud-native**: Kubernetes operators and cloud integrations
+
+⚠️ **Breaking changes**: [Migration Guide v0.0.4](docs/breaking_change_v0.0.4.md)
 
-- In the example registry, replace the Array(Hash) datastore with sqlite3 with a vector table to support discovery using semantic search.
-- Treat the agent like a Tool w/r/t RAG for prompts.
-- Add AgentRequest schema to agent's info in the registry.
-- Add AgentResponse schema to define the `result` element in the response JSON payload
 
 ## License
 

data/Rakefile

@@ -6,3 +6,65 @@ require "minitest/test_task"
 Minitest::TestTask.create
 
 task default: :test
+
+# Additional test tasks for Agent99
+require "rake/testtask"
+
+# Unit tests only
+Rake::TestTask.new(:test_unit) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.test_files = FileList["test/agent99/*test*.rb"]
+  t.verbose = true
+end
+
+# Integration tests only
+Rake::TestTask.new(:test_integration) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.test_files = FileList["test/integration/*test*.rb"]
+  t.verbose = true
+end
+
+# System tests only
+Rake::TestTask.new(:test_system) do |t|
+  t.libs << "lib"
+  t.libs << "test"  
+  t.test_files = FileList["test/system/*test*.rb"]
+  t.verbose = true
+end
+
+desc "Run tests with coverage reporting (requires simplecov gem)"
+task :test_coverage do
+  ENV["COVERAGE"] = "true"
+  Rake::Task[:test].invoke
+end
+
+desc "Run tests in verbose mode"
+task :test_verbose do
+  ENV["VERBOSE"] = "true"
+  Rake::Task[:test].invoke
+end
+
+desc "Show test statistics"
+task :test_stats do
+  unit_tests = Dir.glob("test/agent99/*test*.rb").size
+  integration_tests = Dir.glob("test/integration/*test*.rb").size
+  system_tests = Dir.glob("test/system/*test*.rb").size
+  total_tests = unit_tests + integration_tests + system_tests
+  
+  puts "Test Statistics:"
+  puts "  Unit tests: #{unit_tests}"
+  puts "  Integration tests: #{integration_tests}"
+  puts "  System tests: #{system_tests}"
+  puts "  Total test files: #{total_tests}"
+  
+  # Count test methods
+  test_methods = 0
+  Dir.glob("test/**/*test*.rb").each do |file|
+    content = File.read(file)
+    test_methods += content.scan(/def test_/).size
+  end
+  
+  puts "  Total test methods: #{test_methods}"
+end

data/docs/AI/htm.md

@@ -0,0 +1,215 @@
+# Hierarchical Temporal Memory in AI Systems
+
+## Table of Contents
+- [Introduction](#introduction)
+- [Understanding Hierarchical Temporal Memory](#understanding-hierarchical-temporal-memory)
+- [Layers of Memory](#layers-of-memory)
+- [Topic Columns](#topic-columns)
+- [Memory Cell Promotion and Forgetting](#memory-cell-promotion-and-forgetting)
+- [Implications for AI Systems](#implications-for-ai-systems)
+- [Conclusion](#conclusion)
+- [Some Code Ideas](#some-code-ideas)
+
+## Introduction
+
+Hierarchical Temporal Memory (HTM) is a computational model that mimics some aspects of the neocortex, developed by the Numenta research company. It focuses on how the brain processes information over time and is designed to learn patterns and sequences in data. HTM operates on principles of hierarchy, meaning it organizes information in layers, and temporal memory, which enables it to remember sequences and make predictions based on temporal patterns. This model is particularly effective for tasks involving time series data and has applications in anomaly detection, robotics, and various cognitive computing tasks.
+
+## Understanding Hierarchical Temporal Memory
+
+Hierarchical Temporal Memory is inspired by the theory of how the brain works, particularly focusing on how it learns patterns and sequences. The fundamental ideas were put forward by Jeff Hawkins, co-founder of Numenta, who theorized that real intelligence is derived from understanding and manipulating temporal sequences.
+
+HTM leverages a structure that is hierarchical and spatially organized. Each level of the hierarchy processes information at varying degrees of abstraction. The bottom layers deal with raw sensory input, while the upper layers interpret this data into meaningful contexts.
+
+This model is particularly valuable in applications involving complex time series, where the demand for understanding sequences over time is crucial. The capability of HTM to generalize from sparse data makes it unique compared to traditional machine learning techniques.
+
+## Layers of Memory
+
+HTM's architecture consists of several layers, each designed for specific functions. The bottom layer, known as the input layer, is responsible for receiving raw data inputs. Subsequent layers process this information, identifying patterns and sequences that inform decisions.
+
+1. **Input Layer**: Receives sensory data and converts it into a usable format for the next layer.
+2. **Temporal Pooling Layer**: Captures the temporal dependencies in the data.
+3. **Spatial Pooling Layer**: Encodes spatial relationships and builds a representation of the input data.
+
+This multi-layered approach enables HTM to build increasingly sophisticated representations of the data at each layer, akin to how the neocortex might operate.
+
+## Topic Columns
+
+Each "column" in HTM can be viewed as a mini-neural network that processes input from the layer below it. These columns work in parallel to learn spatial and temporal patterns. Thus, they respond to specific features of the incoming data, allowing HTM to develop a hierarchy of data features. Columns also facilitate learning through inhibition, promoting the most active neurons while suppressing others.
+
+## Memory Cell Promotion and Forgetting
+
+The mechanisms by which HTM promotes or forgets memory cells mirror more biological processes. 
+
+### Promotion
+
+Cells that consistently provide accurate predictions based on the learned sequence are promoted. For instance, if certain neurons within a column recognize patterns that lead to accurate outcomes, they're trained to engage more actively depending on their performance over time.
+
+### Forgetting
+
+Forgetting is equally important; neurons that fail to respond to valid sequences are gradually demoted. This ensures that the model does not become overly reliant on outdated information, allowing new patterns and sequences to emerge and be incorporated.
+
+## Implications for AI Systems
+
+By modeling the functioning of the neocortex, HTM introduces a new paradigm in machine learning, emphasizing time and sequences over static data processing. This has significant implications in various fields:
+
+- **Anomaly Detection**: In finance, HTM can be used to identify unusual patterns in transactions that may indicate fraud.
+- **Robotics**: Robots leveraging HTM can learn from their experiences in real-time, adapting to environmental changes dynamically.
+- **Natural Language Processing**: Understanding the temporal relationships between phrases can enhance language models, leading to more contextually accurate interpretations.
+
+## Conclusion
+
+Hierarchical Temporal Memory presents a powerful framework for understanding and replicating the cognitive processes of the human brain. With its ability to learn from temporal patterns, it opens new frontiers in artificial intelligence and machine learning.
+
+## Some Code Ideas
+
+```ruby
+require 'active_record'
+
+class CreateHtmTable < ActiveRecord::Migration[7.0]
+  def change
+    create_table :htm do |t|
+      t.uuid     :event,         null: false
+      t.text     :proposition,   null: false
+      t.string   :state,         null: false
+      t.datetime :last_accessed, null: false
+      t.integer  :hit_count,     null: false, default: 0
+      t.float    :vector,        null: false, array: true, limit: 2048
+
+      t.timestamps
+    end
+
+    add_index :htm, :event, unique: true
+    add_index :htm, :state
+
+    execute <<-SQL
+      ALTER TABLE htm
+      ADD CONSTRAINT check_state
+      CHECK (state IN ('STM', 'MTM', 'LTM', 'PM'))
+    SQL
+
+    execute <<-SQL
+      ALTER TABLE htm
+      ADD CONSTRAINT check_vector_length
+      CHECK (array_length(vector, 1) = 2048)
+    SQL
+  end
+end
+```
+
+This is a notional model for the table. I'm having second thoughts about keeping track of the hit count. I think maybe access time is all that is needed and that is provided by the AR timestamps.
+
+```ruby
+require 'active_record'
+require 'neighbors'
+
+class Htm < ActiveRecord::Base
+  STATES = %w[STM MTM LTM PM].freeze
+
+  validates :event,       presence: true
+  validates :proposition, presence: true
+  validates :state,       presence: true, inclusion: { in: STATES }
+  validates :vector,      presence: true, length: { is: 2048 }
+
+  def self.search_and_update(event_uuid:, query_vector:, top_k: 10)
+    records = where(event: event_uuid)
+    vectors = records.pluck(:vector)
+
+    neighbor_search = Neighbors::NearestNeighbors.new(vectors)
+    nearest_indices = neighbor_search.search(query_vector, k: top_k)
+
+    nearest_records = records.where(id: records.ids.values_at(*nearest_indices))
+    
+    nearest_records.each do |record|
+      record.hit_count     += 1
+      record.last_accessed  = Time.current
+      record.save!
+    end
+
+    nearest_records
+  end
+
+  def update_state
+    event_config = StateConfig.find_by(event: event)
+    current_time = Time.current
+    time_since_creation = current_time - created_at
+    time_since_last_access = current_time - last_accessed
+
+    if should_promote?(event_config, time_since_creation)
+      promote_state
+    elsif should_demote?(event_config, time_since_last_access)
+      demote_state
+    end
+  end
+
+  private
+
+  def should_promote?(config, time_delta)
+    current_state_index = STATES.index(state)
+    return false if current_state_index == STATES.length - 1
+
+    next_state = STATES[current_state_index + 1]
+    time_delta > config.promotion_time(next_state) &&
+      hit_count > config.promotion_hits(next_state)
+  end
+
+  def should_demote?(config, time_delta)
+    current_state_index = STATES.index(state)
+    return false if current_state_index == 0
+
+    time_delta < config.demotion_time(state) &&
+      hit_count < config.demotion_hits(state)
+  end
+
+  def promote_state
+    current_index = STATES.index(state)
+    self.state    = STATES[current_index + 1] if current_index < STATES.length - 1
+    save!
+  end
+
+  def demote_state
+    current_index = STATES.index(state)
+    self.state    = STATES[current_index - 1] if current_index > 0
+    save!
+  end
+end
+
+class StateConfig < ActiveRecord::Base
+  def promotion_time(state)
+    case state
+    when 'MTM' then mtm_promotion_time
+    when 'LTM' then ltm_promotion_time
+    when 'PM'  then pm_promotion_time
+    else 0
+    end
+  end
+
+  def promotion_hits(state)
+    case state
+    when 'MTM' then mtm_promotion_hits
+    when 'LTM' then ltm_promotion_hits
+    when 'PM'  then pm_promotion_hits
+    else 0
+    end
+  end
+
+  def demotion_time(state)
+    case state
+    when 'MTM' then mtm_demotion_time
+    when 'LTM' then ltm_demotion_time
+    when 'PM'  then pm_demotion_time
+    else Float::INFINITY
+    end
+  end
+
+  def demotion_hits(state)
+    case state
+    when 'MTM' then mtm_demotion_hits
+    when 'LTM' then ltm_demotion_hits
+    when 'PM'  then pm_demotion_hits
+    else Float::INFINITY
+    end
+  end
+end
+```
+
+