language-operator 0.1.63 → 0.1.65

data/lib/language_operator/templates/schema/CHANGELOG.md

@@ -12,6 +12,34 @@ The schema version is tied directly to the gem version and follows [Semantic Ver
 
 ## Version History
 
+### 0.1.64 (2025-11-27)
+
+**Learning Status & Observability Improvements**
+
+This release enhances the learning status tracking and observability features for agents.
+
+**New Features:**
+- Added semantic OpenTelemetry attributes for learning status tracking
+- Implemented Kubernetes event emission for agent-operator communication
+- Real execution metrics from learning status ConfigMap integration
+
+**Improvements:**
+- Enhanced `aictl agent learning-status` command with color-coded boxes and better clarity
+- Changed terminology from "Runs Completed" to "Runs Processed"
+- Improved learning status display formatting with cyan highlighted boxes
+- Restructured learning status into two clear informational boxes
+
+**Bug Fixes:**
+- Handle empty string `lastExecution` in ConfigMap data
+- Fixed SigNoz Query Builder v5 select fields usage
+- Fixed K8s::Resource annotations handling in learning status command
+- Resolved hanging tests and improved test output visibility
+
+**Test Improvements:**
+- Added comprehensive aictl smoke test playbook
+- Removed obsolete learning adapter specs
+- Fixed OpenTelemetry mocking in task executor event emission test
+
 ### 0.1.34 (2025-11-14)
 
 **DSL v1: Task/Main Primitives Added**

data/lib/language_operator/templates/schema/agent_dsl_openapi.yaml

@@ -2,7 +2,7 @@
 :openapi: 3.0.3
 :info:
   :title: Language Operator Agent API
-  :version: 0.1.63
+  :version: 0.1.65
   :description: HTTP API endpoints exposed by Language Operator reactive agents
   :contact:
     :name: Language Operator

data/lib/language_operator/templates/schema/agent_dsl_schema.json

@@ -3,7 +3,7 @@
   "$id": "https://github.com/language-operator/language-operator-gem/schema/agent-dsl.json",
   "title": "Language Operator Agent DSL",
   "description": "Schema for defining autonomous AI agents using the Language Operator DSL",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/type_coercion.rb

@@ -19,7 +19,7 @@ module LanguageOperator
   # - integer: Coerces String, Integer, Float to Integer
   # - number: Coerces String, Integer, Float to Float
   # - string: Coerces any value to String via to_s
-  # - boolean: Coerces String, Boolean to Boolean (explicit values only)
+  # - boolean: Coerces String, Integer (0 or 1), Boolean to Boolean (explicit values only)
   # - array: Strict validation (no coercion)
   # - hash: Strict validation (no coercion)
   # - any: No coercion, passes through any value
@@ -32,8 +32,11 @@ module LanguageOperator
   # @example Boolean coercion
   #   TypeCoercion.coerce("true", "boolean")   # => true
   #   TypeCoercion.coerce("1", "boolean")      # => true
+  #   TypeCoercion.coerce(1, "boolean")        # => true
+  #   TypeCoercion.coerce(0, "boolean")        # => false
   #   TypeCoercion.coerce("false", "boolean")  # => false
   #   TypeCoercion.coerce("maybe", "boolean")  # raises ArgumentError
+  #   TypeCoercion.coerce(2, "boolean")        # raises ArgumentError
   #
   # @example String coercion (never fails)
   #   TypeCoercion.coerce(:symbol, "string")  # => "symbol"
@@ -213,11 +216,11 @@ module LanguageOperator
 
     # Coerce value to Boolean
     #
-    # Accepts: Boolean, String (explicit values only)
+    # Accepts: Boolean, Integer (0 or 1), String (explicit values only)
     # Coercion: Case-insensitive string matching with optimized pattern lookup
-    # Truthy: "true", "1", "yes", "t", "y"
-    # Falsy: "false", "0", "no", "f", "n"
-    # Errors: Ambiguous values (e.g., "maybe", "unknown")
+    # Truthy: "true", "1", "yes", "t", "y", 1 (integer)
+    # Falsy: "false", "0", "no", "f", "n", 0 (integer)
+    # Errors: Ambiguous values (e.g., "maybe", "unknown"), integers other than 0 or 1
     #
     # @param value [Object] Value to coerce
     # @return [Boolean] Coerced boolean
@@ -227,17 +230,28 @@ module LanguageOperator
     #   coerce_boolean(true)      # => true
     #   coerce_boolean("true")    # => true
     #   coerce_boolean("1")       # => true
+    #   coerce_boolean(1)         # => true
     #   coerce_boolean("yes")     # => true
     #   coerce_boolean(false)     # => false
     #   coerce_boolean("false")   # => false
     #   coerce_boolean("0")       # => false
+    #   coerce_boolean(0)         # => false
     #   coerce_boolean("no")      # => false
     #   coerce_boolean("maybe")   # raises ArgumentError
+    #   coerce_boolean(2)         # raises ArgumentError
     def self.coerce_boolean(value)
       # Fast path for already-correct types
       return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
 
-      # Only allow string values for coercion (not integers or other types)
+      # Handle integer 0 and 1 (common in many programming contexts)
+      if value.is_a?(Integer)
+        return true if value == 1
+        return false if value.zero?
+
+        raise ArgumentError, "Cannot coerce #{value.inspect} to boolean (only 0 and 1 are valid integers)"
+      end
+
+      # Only allow string values for coercion (not floats, symbols, or other types)
       raise ArgumentError, "Cannot coerce #{value.inspect} to boolean" unless value.is_a?(String)
 
       # Optimized pattern matching using pre-compiled arrays
@@ -308,9 +322,9 @@ module LanguageOperator
           errors: 'Never (everything has to_s)'
         },
         'boolean' => {
-          accepts: 'Boolean, String (explicit values)',
+          accepts: 'Boolean, Integer (0 or 1), String (explicit values)',
           method: 'Pattern matching (true/1/yes/t/y or false/0/no/f/n)',
-          errors: 'Ambiguous values'
+          errors: 'Ambiguous values, integers other than 0 or 1'
         },
         'array' => {
           accepts: 'Array only',

data/lib/language_operator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LanguageOperator
-  VERSION = '0.1.63'
+  VERSION = '0.1.65'
 end

data/synth/002/agent.rb

@@ -1,22 +1,33 @@
-# frozen_string_literal: true
-
 require 'language_operator'
 
-agent 'test-agent' do
-  description 'Tell a fortune every 10 minutes'
+agent "s002" do
+  description "Tell me a fortune every 10 minutes"
+
   mode :scheduled
-  schedule '*/10 * * * *'
+  schedule "*/10 * * * *"
+
+  task :generate_fortune,
+    instructions: "Generate a short, positive fortune message. Keep it under 100 words. Make it inspiring and uplifting.",
+    inputs: {},
+    outputs: { fortune: 'string' }
 
-  task :tell_fortune,
-       instructions: 'Generate a random fortune message',
-       inputs: {},
-       outputs: { fortune: 'string' }
+  task :format_output,
+    instructions: "Format the fortune message into a readable output string with a title 'Your Fortune:'",
+    inputs: { fortune: 'string' },
+    outputs: { message: 'string' }
+
+  main do |inputs|
+    fortune = execute_task(:generate_fortune)
+    output = execute_task(:format_output, inputs: fortune)
+    output
+  end
 
-  main do |_inputs|
-    execute_task(:tell_fortune)
+  constraints do
+    max_iterations 999999
+    timeout "10m"
   end
 
   output do |outputs|
-    puts outputs[:fortune]
+    puts outputs[:message]
   end
 end

data/synth/002/output.log

@@ -1,21 +1,94 @@
+⚬ Streaming logs for agent 's002'...
+
+⚬ Language Operator v0.1.61
 ⚬ OpenTelemetry disabled
-⚬ Configuring LLM (provider=openai_compatible, model=mistralai/magistral-small-2509, timeout=300)
+⚬ Configuring LLM (provider=openai_compatible, model=qwen3-coder:30b, timeout=300)
 ⚬ LLM configuration complete
 ⚬ No MCP servers configured, agent will run without tools
-⚬ Chat session initialized (with_tools=false)
-⚬ Executing main block (agent=test-agent, task_count=1)
+⚬ Chat session initialized (with_tools=false, total_tools=0)
+⚬ Agent running in scheduled mode - executing once (agent_name=s002, dsl_version=v1)
+⚬ Executing main block (agent=s002, task_count=2)
 ⚬ Executing main block (inputs_keys=[])
-⚬ Executing task (task=tell_fortune, type=neural, timeout=240.0, max_retries=3)
-⚬ Sending prompt to LLM (task=tell_fortune, prompt_length=417)
-⚬ LLM response received, extracting content (task=tell_fortune)
-⚬ Neural task response received (task=tell_fortune, response_length=3617)
-⚬ Parsing neural task response (task=tell_fortune)
-⚬ Response parsed successfully (task=tell_fortune, output_keys=[:fortune])
-⚬ Validating task outputs (task=tell_fortune)
-⚬ Main execution (33.916s)
+⚬ Sending prompt to LLM (task=generate_fortune, prompt_length=632, available_tools=[])
+⚬ LLM response received, extracting content (task=generate_fortune, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=generate_fortune, response_length=563)
+⚬ Parsing neural task response (task=generate_fortune)
+⚬ LLM thinking captured (event=llm_thinking, task=generate_fortune, thinking_steps=1, thinking=["\nI need to generate a short, positive fortune message that is inspiring and uplifting, under 100 words. The message should be meaningful and encourage the reader. I'll create a brief, motivational message about perseverance and positive outcomes.\n\n"], thinking_preview=
+I need to generate a short, positive fortune message that is inspiring and uplifting, under 100 w...)
+⚬ Response parsed successfully (task=generate_fortune, output_keys=[:fortune])
+⚬ Validating task outputs (task=generate_fortune)
+⚬ Sending prompt to LLM (task=format_output, prompt_length=918, available_tools=[])
+⚬ LLM response received, extracting content (task=format_output, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=format_output, response_length=583)
+⚬ Parsing neural task response (task=format_output)
+⚬ LLM thinking captured (event=llm_thinking, task=format_output, thinking_steps=1, thinking=["\nI need to format the fortune message into a readable output string with the title 'Your Fortune:' as specified. The input fortune message is already provided and needs to be wrapped with the title. I'll create a JSON object with the formatted message.\n\n"], thinking_preview=
+I need to format the fortune message into a readable output string with the title 'Your Fortune:'...)
+⚬ Response parsed successfully (task=format_output, output_keys=[:message])
+⚬ Validating task outputs (task=format_output)
+⚬ Main execution (13.01s)
 ⚬ Main block completed
-⚬ Main block execution completed (result={fortune: "Your kindness will bring you much happiness."})
-Your kindness will bring you much happiness.
-✔ Agent completed successfully
-
+⚬ Main block execution completed (result={message: "Your Fortune: Every challenge you face today is building strength you didn't know you had. Trust the process, believe in yourself, and remember that brighter days are always ahead. Your hard work and dedication will soon bring rewarding results. Keep moving forward with hope and determination."})
+Your Fortune: Every challenge you face today is building strength you didn't know you had. Trust the process, believe in yourself, and remember that brighter days are always ahead. Your hard work and dedication will soon bring rewarding results. Keep moving forward with hope and determination.
+⚬ Scheduled execution completed - exiting (agent_name=s002)
+⚬ Language Operator v0.1.61
+⚬ OpenTelemetry disabled
+⚬ Configuring LLM (provider=openai_compatible, model=qwen3-coder:30b, timeout=300)
+⚬ LLM configuration complete
+⚬ No MCP servers configured, agent will run without tools
+⚬ Chat session initialized (with_tools=false, total_tools=0)
+⚬ Agent running in scheduled mode - executing once (agent_name=s002, dsl_version=v1)
+⚬ Executing main block (agent=s002, task_count=2)
+⚬ Executing main block (inputs_keys=[])
+⚬ Sending prompt to LLM (task=generate_fortune, prompt_length=632, available_tools=[])
+⚬ LLM response received, extracting content (task=generate_fortune, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=generate_fortune, response_length=707)
+⚬ Parsing neural task response (task=generate_fortune)
+⚬ LLM thinking captured (event=llm_thinking, task=generate_fortune, thinking_steps=1, thinking=["\nI need to create a short, positive fortune message that is inspiring and uplifting, under 100 words. The message should be generally encouraging and positive in nature. Let me think of a message that conveys hope, perseverance, or personal growth in a concise way.\n\nI'll create a fortune that emphasizes the power of persistence and believing in oneself - a common theme that's universally uplifting and inspiring.\n"], thinking_preview=
+I need to create a short, positive fortune message that is inspiring and uplifting, under 100 wor...)
+⚬ Response parsed successfully (task=generate_fortune, output_keys=[:fortune])
+⚬ Validating task outputs (task=generate_fortune)
+⚬ Sending prompt to LLM (task=format_output, prompt_length=893, available_tools=[])
+⚬ LLM response received, extracting content (task=format_output, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=format_output, response_length=745)
+⚬ Parsing neural task response (task=format_output)
+⚬ LLM thinking captured (event=llm_thinking, task=format_output, thinking_steps=1, thinking=["\nI need to format the fortune message into a readable output string with the title 'Your Fortune:' as requested. The fortune message is quite long, so I'll format it nicely with proper spacing and structure. I'll create a formatted string that includes the title and the fortune content.\n\nI'll create a clean, readable format that presents the fortune in an appealing way while keeping it concise and maintaining the inspirational tone.\n"], thinking_preview=
+I need to format the fortune message into a readable output string with the title 'Your Fortune:'...)
+⚬ Response parsed successfully (task=format_output, output_keys=[:message])
+⚬ Validating task outputs (task=format_output)
+⚬ Main execution (12.698s)
+⚬ Main block completed
+⚬ Main block execution completed (result={message: "Your Fortune:\n\nEvery challenge you face today is building the strength you'll need for tomorrow. Believe in your ability to grow through difficulties and trust that better days are ahead. You have within you everything you need to succeed and create the life you desire."})
+Your Fortune:
 
+Every challenge you face today is building the strength you'll need for tomorrow. Believe in your ability to grow through difficulties and trust that better days are ahead. You have within you everything you need to succeed and create the life you desire.
+⚬ Scheduled execution completed - exiting (agent_name=s002)
+⚬ Language Operator v0.1.61
+⚬ OpenTelemetry disabled
+⚬ Configuring LLM (provider=openai_compatible, model=qwen3-coder:30b, timeout=300)
+⚬ LLM configuration complete
+⚬ No MCP servers configured, agent will run without tools
+⚬ Chat session initialized (with_tools=false, total_tools=0)
+⚬ Agent running in scheduled mode - executing once (agent_name=s002, dsl_version=v1)
+⚬ Executing main block (agent=s002, task_count=2)
+⚬ Executing main block (inputs_keys=[])
+⚬ Sending prompt to LLM (task=generate_fortune, prompt_length=632, available_tools=[])
+⚬ LLM response received, extracting content (task=generate_fortune, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=generate_fortune, response_length=591)
+⚬ Parsing neural task response (task=generate_fortune)
+⚬ LLM thinking captured (event=llm_thinking, task=generate_fortune, thinking_steps=1, thinking=["\nI need to create a positive, inspiring fortune message under 100 words. The message should be uplifting and motivational. Let me craft something that feels genuine and encouraging.\n\nThe fortune should be short and impactful, focusing on positivity and inspiration. I'll make sure it's under 100 words as requested.\n"], thinking_preview=
+I need to create a positive, inspiring fortune message under 100 words. The message should be upl...)
+⚬ Response parsed successfully (task=generate_fortune, output_keys=[:fortune])
+⚬ Validating task outputs (task=generate_fortune)
+⚬ Sending prompt to LLM (task=format_output, prompt_length=877, available_tools=[])
+⚬ LLM response received, extracting content (task=format_output, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=format_output, response_length=491)
+⚬ Parsing neural task response (task=format_output)
+⚬ LLM thinking captured (event=llm_thinking, task=format_output, thinking_steps=1, thinking=["\nI need to format the fortune message with the title 'Your Fortune:' as requested. The message should be properly formatted with this title prefix. I'll create a JSON object with the formatted message.\n"], thinking_preview=
+I need to format the fortune message with the title 'Your Fortune:' as requested. The message sho...)
+⚬ Response parsed successfully (task=format_output, output_keys=[:message])
+⚬ Validating task outputs (task=format_output)
+⚬ Main execution (12.256s)
+⚬ Main block completed
+⚬ Main block execution completed (result={message: "Your Fortune: Your kindness creates ripples of joy that extend far beyond what you can see. Every small act of compassion matters, and your positive energy lights up the world around you. Trust in your ability to make a difference, one moment at a time."})
+Your Fortune: Your kindness creates ripples of joy that extend far beyond what you can see. Every small act of compassion matters, and your positive energy lights up the world around you. Trust in your ability to make a difference, one moment at a time.
+⚬ Scheduled execution completed - exiting (agent_name=s002)

data/synth/003/Makefile

@@ -17,8 +17,11 @@ run:
 code:
 	$(AICTL) code $(AGENT)
 
-optimize:
-	OTEL_QUERY_ENDPOINT=$(OTEL_QUERY_ENDPOINT) OTEL_QUERY_API_KEY=$(OTEL_QUERY_API_KEY) OTEL_QUERY_BACKEND=$(OTEL_QUERY_BACKEND) $(AICTL) optimize $(AGENT)
+inspect:
+	$(AICTL) inspect $(AGENT)
+
+learning-status:
+	$(AICTL) learning status $(AGENT)
 
 logs:
 	$(AICTL) logs $(AGENT)

data/synth/004/Makefile

@@ -0,0 +1,54 @@
+.PHONY: create code logs clean events validate run
+
+AGENT := s004
+AICTL := bundle exec ../../bin/aictl agent
+TOOLS := workspace
+
+create:
+	cat instructions.txt | $(AICTL) create --name $(AGENT) --tools "$(TOOLS)"
+
+run:
+	@JOB_NAME=$(AGENT)-$(shell date +%s); \
+	kubectl create job --from=cronjob/$(AGENT) $$JOB_NAME && \
+	trap "kubectl delete job $$JOB_NAME" EXIT; \
+	kubectl wait --for=condition=ready pod -l job-name=$$JOB_NAME --timeout=60s && \
+	kubectl logs -f job/$$JOB_NAME
+
+code:
+	$(AICTL) code $(AGENT)
+
+inspect:
+	$(AICTL) inspect $(AGENT)
+
+logs:
+	$(AICTL) logs $(AGENT)
+
+# Health monitoring specific commands
+events:
+	@echo "=== Checking for Task Completion events ===" && \
+	kubectl get events -n language-operator --field-selector involvedObject.name=$(AGENT) --sort-by='.lastTimestamp' || \
+	echo "No events found - this may indicate observability issues"
+
+validate:
+	@echo "=== Validating observability infrastructure ===" && \
+	echo "1. Checking if agent exists..." && \
+	$(AICTL) inspect $(AGENT) && \
+	echo "2. Checking recent logs..." && \
+	$(AICTL) logs $(AGENT) --tail=20 && \
+	echo "3. Checking for events..." && \
+	make events && \
+	echo "4. Checking CronJob status..." && \
+	kubectl get cronjob $(AGENT) -n language-operator
+
+health:
+	@echo "=== System Health Check Status ===" && \
+	echo "Last execution logs:" && \
+	$(AICTL) logs $(AGENT) --tail=50 | grep -E "(healthy|error|fail|success|reachable)" || \
+	echo "No health status found in recent logs"
+
+clean:
+	$(AICTL) delete $(AGENT) --force
+
+save:
+	$(AICTL) code $(AGENT) --raw > agent.rb
+	$(AICTL) logs $(AGENT) > output.log

data/synth/004/README.md

@@ -0,0 +1,281 @@
+# 004 - System Health Monitoring & Observability Validation
+
+## Instructions
+
+"Check if the system is healthy every 5 minutes and report any issues"
+
+## Significance
+
+This validates observability infrastructure and system self-monitoring capabilities in DSL v1.
+
+While tests 001-003 validated synthesis, neural execution, and learning, this test validates that the system can properly observe and report on its own health - including the critical infrastructure required for observability itself.
+
+This is the first synthesis test focused on infrastructure resilience and event emission validation.
+
+## What This Demonstrates
+
+### 1. Self-Observability Architecture
+
+The synthesized agent should naturally generate tasks that validate:
+- **Kubernetes API connectivity** - Can reach cluster API for event emission
+- **LLM endpoint availability** - Can execute neural tasks
+- **Monitoring system integration** - Can send telemetry data
+- **Event emission functionality** - Task Completion events are generated
+- **Network policy compliance** - Agent can reach required services
+
+### 2. Infrastructure Resilience Testing
+
+```ruby
+# Expected synthesis pattern
+task :check_kubernetes_api,
+  instructions: "Test connectivity to Kubernetes API server",
+  outputs: { reachable: 'boolean', response_time_ms: 'integer' }
+
+task :check_llm_endpoint,
+  instructions: "Verify LLM model is responding",
+  outputs: { available: 'boolean', model_name: 'string' }
+
+task :check_monitoring_system,
+  instructions: "Test OpenTelemetry/monitoring endpoint connectivity",
+  outputs: { telemetry_working: 'boolean', endpoint: 'string' }
+
+task :validate_event_emission,
+  instructions: "Ensure task execution events are being emitted properly",
+  outputs: { events_working: 'boolean', last_event_time: 'string' }
+
+main do |inputs|
+  # Systematic health validation
+  api_status = execute_task(:check_kubernetes_api)
+  llm_status = execute_task(:check_llm_endpoint)
+  monitoring_status = execute_task(:check_monitoring_system)
+  events_status = execute_task(:validate_event_emission)
+  
+  # Overall health determination and reporting
+  overall_healthy = api_status[:reachable] && 
+                   llm_status[:available] && 
+                   monitoring_status[:telemetry_working] &&
+                   events_status[:events_working]
+  
+  {
+    healthy: overall_healthy,
+    components: {
+      kubernetes: api_status,
+      llm: llm_status,
+      monitoring: monitoring_status,
+      events: events_status
+    },
+    timestamp: Time.now.iso8601
+  }
+end
+```
+
+### 3. Scheduled Health Monitoring
+
+```ruby
+mode :scheduled
+schedule "*/5 * * * *"  # Every 5 minutes
+```
+
+Each execution:
+1. Tests all critical infrastructure components
+2. Generates multiple Task Completion events (validation target)
+3. Reports comprehensive health status
+4. Creates telemetry spans for observability
+5. Exits and waits for next scheduled run
+
+### 4. Event Emission Validation (Critical)
+
+This test specifically validates the Task Completion event infrastructure that was failing due to NetworkPolicy issues. Each health check execution should generate:
+
+- **Task Start events** for each health check task
+- **Task Completion events** (success/failure) for each task
+- **OpenTelemetry traces** with health check spans
+- **Agent execution events** for overall run status
+
+**Key Validation**: If Task Completion events are missing, the health check itself reports the observability system as unhealthy.
+
+### 5. Meta-Validation Property
+
+The test has a beautiful self-validating property:
+
+```
+IF observability infrastructure is broken
+THEN health check cannot report properly
+THEN system correctly reports as unhealthy
+THEREFORE test reveals infrastructure issues
+```
+
+This makes it impossible for observability problems to hide - they become part of the health status.
+
+## Why This Matters
+
+### Fills Critical Testing Gap
+
+Current synthesis test coverage:
+- ✅ **001**: Basic synthesis functionality
+- ✅ **002**: Neural task execution + scheduling  
+- ✅ **003**: Progressive learning + optimization
+- ✅ **004**: Infrastructure resilience + observability
+
+### Validates Production Readiness
+
+Real-world deployments require:
+- **Health monitoring** - System can detect its own problems
+- **Event emission** - Observability data is generated correctly
+- **Network policies** - Security restrictions don't break functionality
+- **Infrastructure dependencies** - All required services are reachable
+
+### Catches Infrastructure Configuration Errors
+
+This test would immediately detect:
+- NetworkPolicy blocking Kubernetes API access
+- Broken OpenTelemetry configuration
+- LLM endpoint connectivity issues
+- Missing RBAC permissions for event creation
+- Firewall rules blocking required traffic
+
+### Self-Healing Validation
+
+The test validates that agents can:
+- Detect infrastructure problems
+- Report issues clearly
+- Continue functioning despite partial failures
+- Provide actionable diagnostic information
+
+## Real-World Use Cases This Enables
+
+### Cluster Health Monitoring
+```ruby
+# Production monitoring agent
+"Monitor cluster resources and alert if anything is degraded"
+# → Generates comprehensive cluster health dashboard
+```
+
+### Service Dependency Validation  
+```ruby
+# Service mesh health checking
+"Test all service connections and report any broken integrations"
+# → Validates microservice communication patterns
+```
+
+### Infrastructure Compliance Auditing
+```ruby
+# Security and compliance monitoring  
+"Check if all security policies are working correctly"
+# → Validates network policies, RBAC, pod security standards
+```
+
+### Self-Healing System Validation
+```ruby
+# Resilience testing
+"Verify the system can recover from common failure scenarios"
+# → Tests automatic recovery mechanisms
+```
+
+## Expected Synthesis Outcomes
+
+### Neural Phase (Initial Synthesis)
+- **All tasks neural** - Uses LLM to determine health check methods
+- **Flexible validation** - Adapts to different infrastructure configurations
+- **Comprehensive checking** - Tests all critical system components
+
+### Learning Phase (After Pattern Detection)
+- **Deterministic checks become symbolic** - API connectivity, endpoint tests
+- **Complex analysis stays neural** - Overall health determination, anomaly detection
+- **Optimized execution** - Faster, cheaper health checks over time
+
+### Progressive Optimization
+```ruby
+# Run 1-10: All neural health checks
+# Run 11+: Learned symbolic implementations for standard checks
+# Always: Neural analysis of overall system health patterns
+```
+
+## Validation Criteria
+
+### Infrastructure Health
+- [ ] Kubernetes API connectivity verified
+- [ ] LLM endpoint responsiveness confirmed  
+- [ ] Monitoring system integration working
+- [ ] Network policies allow required access
+
+### Event Emission
+- [ ] Task Completion events generated for each task
+- [ ] Events contain proper metadata and timing
+- [ ] OpenTelemetry traces collected successfully
+- [ ] No event emission timeout errors
+
+### Error Handling
+- [ ] Graceful handling of connectivity failures
+- [ ] Clear reporting of specific issues
+- [ ] Continued operation despite partial failures
+- [ ] Actionable diagnostic information provided
+
+### Schedule Reliability
+- [ ] Executions occur every 5 minutes as scheduled
+- [ ] Consistent performance across runs
+- [ ] Proper cleanup after each execution
+- [ ] No resource leaks or accumulation
+
+## Comparison to Traditional Monitoring
+
+### Traditional Approach (Prometheus/Nagios)
+```yaml
+# Static configuration, manual setup
+- name: check_api
+  command: curl -f https://k8s-api/healthz
+  interval: 5m
+  
+- name: check_llm  
+  command: curl -f https://llm-endpoint/health
+  interval: 5m
+```
+
+### Language Operator Approach (Organic Functions)
+```ruby
+# Natural language → comprehensive monitoring
+"Check if the system is healthy every 5 minutes and report any issues"
+
+# Synthesizes intelligent monitoring that:
+# - Adapts to infrastructure changes
+# - Learns optimal check patterns  
+# - Provides contextual analysis
+# - Integrates with existing observability
+```
+
+## Files Generated
+
+| File | Purpose |
+|------|---------|
+| `instructions.txt` | Single-sentence natural language instruction |
+| `agent.synthesized.rb` | Initial neural health monitoring agent |
+| `Makefile` | Synthesis and execution commands |
+| `output.log` | Health check execution logs |
+
+## Synthesis Commands
+
+```bash
+# Create and deploy health monitoring agent
+make create
+
+# Monitor health check execution
+make logs
+
+# Check for Task Completion events
+make events
+
+# Validate observability infrastructure
+make validate
+```
+
+## Expected Impact
+
+This test validates that Language Operator can synthesize production-ready monitoring infrastructure from a simple natural language instruction, while ensuring the observability systems required for operational visibility are functioning correctly.
+
+The zen aspect: A simple request for health monitoring becomes a comprehensive validation of the entire system's ability to observe itself.
+
+## Related Tests
+
+- [001 - Minimal Synthesis](../001/README.md) - Basic synthesis validation
+- [002 - Neural Execution](../002/README.md) - Neural task execution + scheduling  
+- [003 - Progressive Learning](../003/README.md) - Learning and optimization

data/synth/004/instructions.txt

@@ -0,0 +1 @@
+Check if the system is healthy every 5 minutes and report any issues