self_agency 0.0.1

data/examples/11_collaborative_robots/main.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# 11_collaborative_robots/main.rb — Collaborative Robots Demo
+#
+# Demonstrates:
+#   - Two-layer LLM approach: analyze task -> generate methods via _()
+#   - Three robots collaborating through a shared message bus
+#   - Pipeline execution: data generation -> analysis -> reporting
+#
+# Requires a running Ollama instance with the configured model.
+
+require_relative "robot"
+
+# ---------------------------------------------------------------------------
+# Create message bus and robots
+# ---------------------------------------------------------------------------
+
+puts "=== Collaborative Robots — Weather Data Pipeline ==="
+puts ""
+
+bus = MessageBus.new
+
+atlas = Robot.new(
+  name: "Atlas",
+  task: <<~TASK,
+    You are a data generator robot. Create exactly two instance methods:
+
+    1. Method named 'generate_weather_data' that takes no parameters.
+       It must return an Array of 24 Hashes (one per hour, index 0..23).
+       Each Hash has these keys (all Symbols):
+         :hour        => the integer hour (0..23)
+         :temperature => a Float computed as 20.0 + 8.0 * Math.sin((hour - 6) * Math::PI / 12.0)
+         :humidity    => a Float computed as 60.0 + 20.0 * Math.cos((hour - 14) * Math::PI / 12.0)
+         :wind_speed  => a Float computed as 10.0 + 5.0 * Math.sin((hour * 7) * Math::PI / 24.0)
+       Do NOT use random numbers. Use only the deterministic formulas above.
+
+    2. Method named 'summarize_raw_data' that takes one parameter (data),
+       an Array of Hashes as described above. It returns a Hash with:
+         :readings_count => data.size
+         :raw_data       => data
+         :source         => "Atlas"
+  TASK
+  bus: bus
+)
+
+puts ""
+
+nova = Robot.new(
+  name: "Nova",
+  task: <<~TASK,
+    You are an analyzer robot. Create exactly two instance methods:
+
+    1. Method named 'compute_basic_statistics' that takes one parameter (data),
+       a Hash with key :raw_data containing an Array of Hashes. Each inner Hash
+       has keys :temperature, :humidity, :wind_speed (all Floats).
+       Compute and return a Hash with:
+         :avg_temp      => average of all :temperature values, rounded to 1 decimal
+         :min_temp      => minimum :temperature value, rounded to 1 decimal
+         :max_temp      => maximum :temperature value, rounded to 1 decimal
+         :avg_humidity  => average of all :humidity values, rounded to 1 decimal
+         :avg_wind      => average of all :wind_speed values, rounded to 1 decimal
+         :readings      => data[:readings_count]
+         :source        => data[:source]
+       Use .round(1) for all Float results.
+
+    2. Method named 'classify_conditions' that takes one parameter (stats),
+       a Hash with keys :avg_temp, :avg_humidity, :avg_wind (all Floats).
+       Determine classifications:
+         - temperature_class: "cold" if avg_temp < 15, "mild" if < 25, else "hot"
+         - humidity_class: "dry" if avg_humidity < 40, "comfortable" if < 70, else "humid"
+         - wind_class: "calm" if avg_wind < 8, "breezy" if < 15, else "windy"
+       Return stats.merge with the three new keys (:temperature_class, :humidity_class,
+       :wind_class) added, preserving all existing keys.
+  TASK
+  bus: bus
+)
+
+puts ""
+
+echo = Robot.new(
+  name: "Echo",
+  task: <<~TASK,
+    You are a reporter robot. Create exactly one instance method:
+
+    1. Method named 'format_weather_report' that takes one parameter (data),
+       a Hash with these keys:
+         :avg_temp, :min_temp, :max_temp (Floats)
+         :avg_humidity, :avg_wind (Floats)
+         :temperature_class, :humidity_class, :wind_class (Strings)
+         :readings (Integer), :source (String)
+       Return a formatted multi-line String report like:
+
+       "=== Weather Report ===\\n" +
+       "Source: \#{data[:source]} | Readings: \#{data[:readings]}\\n" +
+       "Temperature: \#{data[:avg_temp]}°  (min: \#{data[:min_temp]}°, max: \#{data[:max_temp]}°) [\#{data[:temperature_class]}]\\n" +
+       "Humidity:    \#{data[:avg_humidity]}% [\#{data[:humidity_class]}]\\n" +
+       "Wind:        \#{data[:avg_wind]} km/h [\#{data[:wind_class]}]\\n" +
+       "======================"
+
+       Use string interpolation. Return the String, do not print it.
+  TASK
+  bus: bus
+)
+
+# ---------------------------------------------------------------------------
+# Display capabilities summary
+# ---------------------------------------------------------------------------
+
+puts ""
+puts "=== Capabilities Summary ==="
+[atlas, nova, echo].each do |robot|
+  puts "#{robot.name}: #{robot.capabilities.inspect}"
+end
+
+puts ""
+puts "=== Generated Source Code ==="
+[atlas, nova, echo].each do |robot|
+  robot.generation_log.each do |entry|
+    puts "--- #{robot.name}##{entry[:method_name]} ---"
+    puts entry[:code]
+    puts ""
+  end
+end
+
+# ---------------------------------------------------------------------------
+# Execute the pipeline
+# ---------------------------------------------------------------------------
+
+puts "=== Executing Pipeline ==="
+puts ""
+
+# Step 1: Atlas generates and summarizes weather data
+puts "Step 1: Atlas generates weather data..."
+atlas_result = atlas.execute
+atlas.send_message(to: "Nova", content: atlas_result)
+puts "Atlas produced #{atlas_result[:raw_data]&.size || 0} readings"
+puts ""
+
+# Step 2: Nova analyzes the data
+puts "Step 2: Nova analyzes the data..."
+nova_input = nova.inbox.last&.dig(:content)
+nova_result = nova.execute(nova_input)
+nova.send_message(to: "Echo", content: nova_result)
+puts "Nova computed statistics and classifications"
+puts ""
+
+# Step 3: Echo formats the report
+puts "Step 3: Echo formats the final report..."
+echo_input = echo.inbox.last&.dig(:content)
+final_report = echo.execute(echo_input)
+puts ""
+
+# ---------------------------------------------------------------------------
+# Display results
+# ---------------------------------------------------------------------------
+
+puts "=== Final Weather Report ==="
+puts final_report.to_s
+puts ""
+
+bus.print_log
+puts ""
+
+# ---------------------------------------------------------------------------
+# Generation statistics
+# ---------------------------------------------------------------------------
+
+puts "=== Generation Statistics ==="
+total_methods = 0
+total_lines   = 0
+[atlas, nova, echo].each do |robot|
+  methods = robot.generation_log.size
+  lines   = robot.generation_log.sum { |e| e[:code].lines.size }
+  total_methods += methods
+  total_lines   += lines
+  puts "#{robot.name}: #{methods} method(s), #{lines} lines of generated code"
+end
+puts "Total: #{total_methods} methods, #{total_lines} lines of generated code"
+
+# ---------------------------------------------------------------------------
+# Save generated robots as subclasses
+# ---------------------------------------------------------------------------
+
+puts ""
+puts "=== Saving Generated Robots ==="
+[atlas, nova, echo].each do |robot|
+  path = robot._save!(as: robot.name)
+  puts "#{robot.name}: saved to #{path}"
+end

data/examples/11_collaborative_robots/nova.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "robot"
+
+class Nova < Robot
+  # Compute basic statistics from raw data. Takes one parameter (data), a Hash with key :raw_data containing an Array of Hashes. Each inner Hash has keys :temperature, :humidity, :wind_speed (all Floats). Compute and return a Hash with: :avg_temp => average of all :temperature values, rounded to 1 decimal, :min_temp => minimum :temperature value, rounded to 1 decimal, :max_temp => maximum :temperature value, rounded to 1 decimal, :avg_humidity => average of all :humidity values, rounded to 1 decimal, :avg_wind => average of all :wind_speed values, rounded to 1 decimal, :readings => data[:readings_count], :source => data[:source]. Use .round(1) for all Float results.
+  def compute_statistics(data)
+    raw_data = data[:raw_data]
+    readings_count = data[:readings_count]
+    source = data[:source]
+    
+    temperatures = []
+    humidities = []
+    wind_speeds = []
+    
+    raw_data.each do |reading|
+      temperatures << reading[:temperature]
+      humidities << reading[:humidity]
+      wind_speeds << reading[:wind_speed]
+    end
+    
+    avg_temp = (temperatures.sum / temperatures.length.to_f).round(1)
+    min_temp = temperatures.min.round(1)
+    max_temp = temperatures.max.round(1)
+    avg_humidity = (humidities.sum / humidities.length.to_f).round(1)
+    avg_wind = (wind_speeds.sum / wind_speeds.length.to_f).round(1)
+    
+    {
+      :avg_temp => avg_temp,
+      :min_temp => min_temp,
+      :max_temp => max_temp,
+      :avg_humidity => avg_humidity,
+      :avg_wind => avg_wind,
+      :readings => readings_count,
+      :source => source
+    }
+  end
+
+  # Classify weather conditions based on statistics. Takes one parameter (stats), a Hash with keys :avg_temp, :avg_humidity, :avg_wind (all Floats). Determine classifications: - temperature_class: "cold" if avg_temp < 15, "mild" if < 25, else "hot" - humidity_class: "dry" if avg_humidity < 40, "comfortable" if < 70, else "humid" - wind_class: "calm" if avg_wind < 8, "breezy" if < 15, else "windy". Return stats.merge with the three new keys (:temperature_class, :humidity_class, :wind_class) added, preserving all existing keys.
+  def classify_weather_conditions(stats)
+    temperature_class = if stats[:avg_temp] < 15.0
+                         "cold"
+                       elsif stats[:avg_temp] < 25.0
+                         "mild"
+                       else
+                         "hot"
+                       end
+
+    humidity_class = if stats[:avg_humidity] < 40.0
+                       "dry"
+                     elsif stats[:avg_humidity] < 70.0
+                       "comfortable"
+                     else
+                       "humid"
+                     end
+
+    wind_class = if stats[:avg_wind] < 8.0
+                   "calm"
+                 elsif stats[:avg_wind] < 15.0
+                   "breezy"
+                 else
+                   "windy"
+                 end
+
+    stats.merge(
+      temperature_class: temperature_class,
+      humidity_class: humidity_class,
+      wind_class: wind_class
+    )
+  end
+end

data/examples/11_collaborative_robots/robot.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# robot.rb — Robot class with two-layer LLM self-generation
+#
+# Layer 1 (Analyze): Direct RubyLLM.chat().ask() decomposes a task into
+#   a JSON array of method specifications.
+# Layer 2 (Generate): Loops through specs, calls _() for each.
+#   SelfAgency handles shape -> generate -> validate -> sandbox eval.
+
+require "json"
+require_relative "../lib/message_bus"
+require_relative "../lib/setup"
+
+class Robot
+  include SelfAgency
+
+  attr_reader :name, :task, :bus, :inbox, :capabilities, :generation_log
+
+  def initialize(name:, task:, bus:)
+    @name           = name
+    @task           = task
+    @bus            = bus
+    @inbox          = []
+    @capabilities   = []
+    @generation_log = []
+
+    bus.register(self)
+
+    puts "#{@name}: Analyzing task..."
+    specs = analyze_task(task)
+    puts "#{@name}: Found #{specs.size} method(s) to generate"
+
+    specs.each do |spec|
+      method_name = spec["name"]
+      description = spec["description"]
+      puts "#{@name}: Generating '#{method_name}' — #{description}"
+
+      begin
+        defined_methods = _(description)
+        @capabilities.concat(defined_methods)
+        puts "#{@name}: Successfully generated #{defined_methods.inspect}"
+      rescue SelfAgency::Error => e
+        puts "#{@name}: Failed to generate '#{method_name}': #{e.message}"
+      end
+    end
+
+    puts "#{@name}: Ready with capabilities: #{@capabilities.inspect}"
+  end
+
+  def execute(input = nil)
+    result = nil
+
+    @capabilities.each do |cap|
+      arity = method(cap).arity
+
+      if arity == 0 && result.nil?
+        result = public_send(cap)
+      elsif arity != 0 && !result.nil?
+        result = public_send(cap, result)
+      elsif arity != 0 && result.nil? && !input.nil?
+        result = public_send(cap, input)
+      end
+    end
+
+    result
+  end
+
+  def receive_message(from:, content:)
+    @inbox << { from: from, content: content }
+    puts "#{@name}: Received message from #{from}"
+  end
+
+  def send_message(to:, content:)
+    @bus.deliver(from: @name, to: to, content: content)
+  end
+
+  def broadcast(content:)
+    @bus.broadcast(from: @name, content: content)
+  end
+
+  def on_method_generated(method_name, scope, code)
+    @generation_log << { method_name: method_name, scope: scope, code: code }
+  end
+
+  private
+
+  def analyze_task(description)
+    cfg  = SelfAgency.configuration
+    chat = RubyLLM.chat(model: cfg.model, provider: cfg.provider)
+
+    prompt = <<~PROMPT
+      You are a task decomposition engine. Given a task description, return a JSON
+      array of method specifications. Each element must have:
+        - "name": the Ruby method name (snake_case), exactly as specified in the task
+        - "description": a precise description for a Ruby code generator that
+          preserves EVERY identifier verbatim from the task — method names, parameter
+          names, Hash key names (as Ruby Symbols), return types, thresholds, and
+          formulas. Do NOT paraphrase, rename, or abbreviate any identifier.
+        - "takes_input": boolean, true if the method accepts a parameter
+
+      Respond with ONLY the JSON array. No markdown fences, no explanation.
+
+      Task: #{description}
+    PROMPT
+
+    response = chat.ask(prompt)
+    raw      = response.content.to_s.strip
+
+    # Sanitize the same way SelfAgency does — strip <think> blocks and markdown fences
+    raw = raw.gsub(/<think>.*?<\/think>/m, "")
+    raw = raw.sub(/\A```\w*\n?/, "").sub(/\n?```\s*\z/, "")
+    raw.strip!
+
+    JSON.parse(raw)
+  rescue JSON::ParserError => e
+    puts "#{@name}: Failed to parse task analysis: #{e.message}"
+    []
+  end
+end

data/examples/12_autonomous_robots/analyst.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative "robot"
+
+class Analyst < Robot
+  # Fix the Ruby singleton method 'calculate_statistics' on this Robot instance.
+  # 
+  # Robot's overall goal: Analyze landmark data. The input is an Array of Hashes, each with keys :name (String), :type (String), :duration (Integer), :rating (Float). Return a Hash with three keys: :statistics (a Hash with :avg_rating, :avg_duration, :total_duration, :count), :ranked (the landmarks Array sorted by :rating descending), :by_type (a Hash grouping landmarks by :type)
+  # Generated capabilities on this object: [:calculate_statistics, :sort_by_rating, :group_by_type, :execute_task]
+  # 
+  # Current source code of 'calculate_statistics':
+  # def calculate_statistics(landmarks)
+  #   total_duration = 0
+  #   rating_sum = 0.0
+  #   
+  #   landmarks.each do |landmark|
+  #     total_duration += landmark[:duration]
+  #     rating_sum += landmark[:rating]
+  #   end
+  #   
+  #   avg_rating = landmarks.length > 0 ? rating_sum / landmarks.length : 0.0
+  #   avg_duration = landmarks.length > 0 ? total_duration.to_f / landmarks.length : 0.0
+  #   
+  #   {
+  #     avg_rating: avg_rating,
+  #     avg_duration: avg_duration,
+  #     total_duration: total_duration,
+  #     count: landmarks.length
+  #   }
+  # end
+  # 
+  # Runtime error:
+  #   NoMethodError: undefined method 'each' for nil
+  # 
+  # Backtrace (top 5):
+  #   (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):5:in 'calculate_statistics'
+  #     (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):2:in 'execute_task'
+  #     /Users/dewayne/sandbox/git_repos/madbomber/self_agency/examples/12_autonomous_robots/robot.rb:72:in 'Robot#perform_task'
+  #     ./main.rb:102:in '<main>'
+  # 
+  # This method takes no external input.
+  # 
+  # Produce a corrected version of this method that avoids the error.
+  # Keep the same method name and signature. Only define this one method.
+  # Fix the bug while preserving the method's intent.
+  def calculate_statistics(landmarks)
+    landmarks = landmarks || []
+    
+    total_duration = 0
+    rating_sum = 0.0
+    count = 0
+    
+    landmarks.each do |landmark|
+      next unless landmark.is_a?(Hash)
+      next unless landmark[:duration].is_a?(Integer)
+      next unless landmark[:rating].is_a?(Float)
+      
+      total_duration += landmark[:duration]
+      rating_sum += landmark[:rating]
+      count += 1
+    end
+    
+    avg_rating = count > 0 ? rating_sum / count : 0.0
+    avg_duration = count > 0 ? total_duration.to_f / count : 0.0
+    
+    statistics = {
+      :avg_rating => avg_rating,
+      :avg_duration => avg_duration,
+      :total_duration => total_duration,
+      :count => count
+    }
+    
+    ranked = landmarks.sort_by { |landmark| -landmark[:rating] }
+    
+    by_type = landmarks.group_by { |landmark| landmark[:type] }
+    
+    {
+      :statistics => statistics,
+      :ranked => ranked,
+      :by_type => by_type
+    }
+  end
+
+  # Fix the Ruby singleton method 'sort_by_rating' on this Robot instance.
+  # 
+  # Robot's overall goal: Analyze landmark data. The input is an Array of Hashes, each with keys :name (String), :type (String), :duration (Integer), :rating (Float). Return a Hash with three keys: :statistics (a Hash with :avg_rating, :avg_duration, :total_duration, :count), :ranked (the landmarks Array sorted by :rating descending), :by_type (a Hash grouping landmarks by :type)
+  # Generated capabilities on this object: [:calculate_statistics, :sort_by_rating, :group_by_type, :execute_task]
+  # 
+  # Current source code of 'sort_by_rating':
+  # def sort_by_rating(landmarks)
+  #   landmarks.sort_by { |landmark| -landmark[:rating] || 0 }
+  # end
+  # 
+  # Runtime error:
+  #   NoMethodError: undefined method 'sort_by' for nil
+  # 
+  # Backtrace (top 5):
+  #   (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):2:in 'sort_by_rating'
+  #     (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):3:in 'execute_task'
+  #     /Users/dewayne/sandbox/git_repos/madbomber/self_agency/examples/12_autonomous_robots/robot.rb:72:in 'Robot#perform_task'
+  #     ./main.rb:102:in '<main>'
+  # 
+  # This method takes no external input.
+  # 
+  # Produce a corrected version of this method that avoids the error.
+  # Keep the same method name and signature. Only define this one method.
+  # Fix the bug while preserving the method's intent.
+  def sort_by_rating(landmarks)
+    return {
+      :statistics => {
+        :average_rating => 0.0,
+        :average_duration => 0.0,
+        :total_duration => 0,
+        :count => 0
+      },
+      :ranked => [],
+      :by_type => {}
+    } if landmarks.nil? || landmarks.empty?
+
+    total_rating = 0.0
+    total_duration = 0
+    count = landmarks.length
+
+    landmarks.each do |landmark|
+      total_rating += landmark[:rating] || 0.0
+      total_duration += landmark[:duration] || 0
+    end
+
+    average_rating = count > 0 ? total_rating / count : 0.0
+    average_duration = count > 0 ? total_duration.to_f / count : 0.0
+
+    ranked = landmarks.sort_by { |landmark| -(landmark[:rating] || 0.0) }
+
+    by_type = ranked.group_by { |landmark| landmark[:type] }
+
+    {
+      :statistics => {
+        :average_rating => average_rating,
+        :average_duration => average_duration,
+        :total_duration => total_duration,
+        :count => count
+      },
+      :ranked => ranked,
+      :by_type => by_type
+    }
+  end
+
+  # def group_by_type(landmarks) -> Hash
+  #   Groups an array of landmark hashes by their type.
+  #   Parameters: landmarks (Array[Hash]) - array of landmark data hashes
+  #   Returns: Hash with type names as keys and Arrays of landmark hashes as values
+  #   Algorithm:
+  #     1. Initialize an empty Hash result
+  #     2. Iterate through each landmark in landmarks array
+  #     3. For each landmark, get the :type key value
+  #     4. If result has a key for this type, append landmark to that array
+  #     5. Otherwise, create new array with landmark as first element
+  #     6. Return the grouped result hash
+  def group_by_type(landmarks)
+    result = {}
+    landmarks.each do |landmark|
+      type = landmark[:type]
+      if result.key?(type)
+        result[type] << landmark
+      else
+        result[type] = [landmark]
+      end
+    end
+    result
+  end
+
+  # An instance method named 'execute_task' that orchestrates the following
+  # goal: Analyze landmark data. The input is an Array of Hashes, each with keys :name (String), :type (String), :duration (Integer), :rating (Float). Return a Hash with three keys: :statistics (a Hash with :avg_rating, :avg_duration, :total_duration, :count), :ranked (the landmarks Array sorted by :rating descending), :by_type (a Hash grouping landmarks by :type)
+  # 
+  # It takes one parameter (input) which is the data passed in from a previous stage.
+  # 
+  # Available helper methods on this object: calculate_statistics, sort_by_rating, group_by_type
+  # 
+  # Call the helper methods in whatever order makes sense to accomplish the goal.
+  # Return the final result. Do NOT define the helper methods — they already exist.
+  # Only define the execute_task method itself.
+  def execute_task(input)
+    statistics = calculate_statistics(input)
+    ranked = sort_by_rating(input)
+    by_type = group_by_type(input)
+    
+    {
+      :statistics => statistics,
+      :ranked => ranked,
+      :by_type => by_type
+    }
+  end
+end

data/examples/12_autonomous_robots/collector.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "robot"
+
+class Collector < Robot
+  # def generate_landmark_data
+  #   landmarks = []
+  #   8.times do |i|
+  #     name = "Landmark #{i + 1}"
+  #     type = ['museum', 'park', 'bridge', 'tower', 'theater', 'garden', 'statue', 'monument'].sample
+  #     duration = rand(30..180)
+  #     rating = (rand(100..500).to_f / 100.0).round(1)
+  #     landmarks << { name: name, type: type, duration: duration, rating: rating }
+  #   end
+  #   landmarks
+  # end
+  def generate_landmark_data
+    landmarks = []
+    8.times do |i|
+      name = "Landmark #{i + 1}"
+      type = ['museum', 'park', 'bridge', 'tower', 'theater', 'garden', 'statue', 'monument'].sample
+      duration = rand(30..180)
+      rating = (rand(100..500).to_f / 100.0).round(1)
+      landmark = { name: name, type: type, duration: duration, rating: rating }
+      landmarks << landmark
+    end
+    landmarks
+  end
+
+  # Fix the Ruby singleton method 'execute_task' on this Robot instance.
+  # 
+  # Robot's overall goal: Return an Array of 8 Hashes representing fictional city landmarks. Each Hash has Symbol keys :name (String), :type (String, e.g. 'museum'), :duration (Integer, 30..180 minutes), :rating (Float, 1.0..5.0). Do NOT wrap the Array in an outer Hash.
+  # Generated capabilities on this object: [:generate_landmark_data, :execute_task]
+  # 
+  # Current source code of 'execute_task':
+  # def execute_task
+  #   landmarks = []
+  #   8.times do
+  #     data = generate_landmark_data
+  #     landmarks << {
+  #       name: data[:name],
+  #       type: data[:type],
+  #       duration: rand(30..180),
+  #       rating: rand(1.0..5.0)
+  #     }
+  #   end
+  #   landmarks
+  # end
+  # 
+  # Runtime error:
+  #   TypeError: no implicit conversion of Symbol into Integer
+  # 
+  # Backtrace (top 5):
+  #   (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):6:in 'block in execute_task'
+  #     (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):3:in 'Integer#times'
+  #     (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):3:in 'execute_task'
+  #     /Users/dewayne/sandbox/git_repos/madbomber/self_agency/examples/12_autonomous_robots/robot.rb:70:in 'Robot#perform_task'
+  #     ./main.rb:94:in '<main>'
+  # 
+  # This method takes no external input.
+  # 
+  # Produce a corrected version of this method that avoids the error.
+  # Keep the same method name and signature. Only define this one method.
+  # Fix the bug while preserving the method's intent.
+  def execute_task
+    landmarks = []
+    8.times do
+      data = generate_landmark_data
+      landmarks << {
+        name: data[:name],
+        type: data[:type],
+        duration: rand(30..180),
+        rating: rand(1.0..5.0)
+      }
+    end
+    landmarks
+  end
+end