language-operator 0.1.58 → 0.1.61

data/lib/language_operator/learning/trace_analyzer.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'logger'
+require_relative 'adapters/base_adapter'
+
+module LanguageOperator
+  module Learning
+    # Analyzes OpenTelemetry traces to detect patterns in task execution
+    #
+    # The TraceAnalyzer queries OTLP backends (SigNoz, Jaeger, Tempo) to retrieve
+    # execution traces for neural tasks, then analyzes them to determine if they
+    # exhibit consistent patterns that can be codified into symbolic implementations.
+    #
+    # Auto-detects available backends in order: SigNoz → Jaeger → Tempo
+    # Falls back gracefully if no backend is available (learning disabled).
+    #
+    # @example Basic usage
+    #   analyzer = TraceAnalyzer.new(
+    #     endpoint: ENV['OTEL_QUERY_ENDPOINT'],
+    #     api_key: ENV['OTEL_QUERY_API_KEY']
+    #   )
+    #
+    #   analysis = analyzer.analyze_patterns(task_name: 'fetch_user_data')
+    #   if analysis && analysis[:consistency] >= 0.85
+    #     puts "Task is ready for learning!"
+    #     puts "Tool sequence: #{analysis[:common_pattern]}"
+    #   end
+    #
+    # @example Explicit backend selection
+    #   ENV['OTEL_QUERY_BACKEND'] = 'signoz'
+    #   analyzer = TraceAnalyzer.new(endpoint: 'https://signoz.example.com')
+    class TraceAnalyzer
+      # Minimum pattern consistency required for learning (configurable)
+      DEFAULT_CONSISTENCY_THRESHOLD = 0.85
+
+      # Default time range for queries (24 hours)
+      DEFAULT_TIME_RANGE = 24 * 60 * 60
+
+      # Initialize trace analyzer with backend connection
+      #
+      # @param endpoint [String, nil] OTLP backend endpoint (auto-detected from ENV if nil)
+      # @param api_key [String, nil] API key for authentication (if required)
+      # @param backend [String, nil] Explicit backend type ('signoz', 'jaeger', 'tempo')
+      # @param logger [Logger, nil] Logger instance (creates default if nil)
+      def initialize(endpoint: nil, api_key: nil, backend: nil, logger: nil)
+        @endpoint = endpoint || ENV.fetch('OTEL_QUERY_ENDPOINT', nil)
+        @api_key = api_key || ENV.fetch('OTEL_QUERY_API_KEY', nil)
+        @backend_type = backend || ENV.fetch('OTEL_QUERY_BACKEND', nil)
+        @logger = logger || ::Logger.new($stdout, level: ::Logger::WARN)
+        @adapter = detect_backend_adapter
+      end
+
+      # Check if learning is available (backend connected)
+      #
+      # @return [Boolean] True if a backend adapter is available
+      def available?
+        !@adapter.nil?
+      end
+
+      # Query task execution traces from backend
+      #
+      # @param task_name [String] Name of task to query
+      # @param agent_name [String, nil] Optional agent name to filter by
+      # @param limit [Integer] Maximum number of traces to return
+      # @param time_range [Integer, Range<Time>] Time range in seconds or explicit range
+      # @return [Array<Hash>] Task execution data
+      def query_task_traces(task_name:, agent_name: nil, limit: 100, time_range: DEFAULT_TIME_RANGE)
+        unless available?
+          @logger.warn('No OTLP backend available, learning disabled')
+          return []
+        end
+
+        range = normalize_time_range(time_range)
+
+        filter = { task_name: task_name }
+        filter[:agent_name] = agent_name if agent_name
+
+        spans = @adapter.query_spans(
+          filter: filter,
+          time_range: range,
+          limit: limit
+        )
+
+        @adapter.extract_task_data(spans)
+      rescue StandardError => e
+        @logger.error("Failed to query task traces: #{e.message}")
+        @logger.debug(e.backtrace.join("\n"))
+        []
+      end
+
+      # Analyze task execution patterns for consistency
+      #
+      # Determines if a neural task exhibits consistent behavior that can be
+      # learned and converted to a symbolic implementation.
+      #
+      # @param task_name [String] Name of task to analyze
+      # @param agent_name [String, nil] Optional agent name to filter by
+      # @param min_executions [Integer] Minimum executions required for analysis
+      # @param consistency_threshold [Float] Required consistency (0.0-1.0)
+      # @param time_range [Integer, Range<Time>, nil] Time range for query (seconds or explicit range)
+      # @return [Hash, nil] Analysis results or nil if insufficient data
+      def analyze_patterns(task_name:, agent_name: nil, min_executions: 10, consistency_threshold: DEFAULT_CONSISTENCY_THRESHOLD,
+                           time_range: nil)
+        executions = query_task_traces(task_name: task_name, agent_name: agent_name, limit: 1000, time_range: time_range || DEFAULT_TIME_RANGE)
+
+        if executions.empty?
+          @logger.info("No executions found for task '#{task_name}'")
+          return nil
+        end
+
+        if executions.size < min_executions
+          @logger.info("Insufficient executions for task '#{task_name}': #{executions.size}/#{min_executions}")
+          return {
+            task_name: task_name,
+            execution_count: executions.size,
+            required_count: min_executions,
+            ready_for_learning: false,
+            reason: "Need #{min_executions - executions.size} more executions"
+          }
+        end
+
+        consistency_data = calculate_consistency(executions)
+
+        # Task is ready for learning only if:
+        # 1. Consistency meets threshold
+        # 2. There's an actual tool pattern to learn (not empty/pure LLM)
+        has_pattern = !consistency_data[:common_pattern].nil? && !consistency_data[:common_pattern].empty?
+        ready = consistency_data[:score] >= consistency_threshold && has_pattern
+
+        {
+          task_name: task_name,
+          execution_count: executions.size,
+          consistency_score: consistency_data[:score],
+          consistency_threshold: consistency_threshold,
+          ready_for_learning: ready,
+          reason: has_pattern ? nil : 'No tool calls to learn (pure LLM task)',
+          common_pattern: consistency_data[:common_pattern],
+          input_signatures: consistency_data[:input_signatures],
+          analysis_timestamp: Time.now.iso8601
+        }
+      end
+
+      # Calculate pattern consistency across executions
+      #
+      # Groups executions by input signature and analyzes tool call sequences
+      # to determine how often the same pattern is used for the same inputs.
+      #
+      # @param executions [Array<Hash>] Task execution data
+      # @return [Hash] Consistency analysis with score and common pattern
+      def calculate_consistency(executions)
+        # Group by input signature
+        by_inputs = executions.group_by { |ex| normalize_inputs(ex[:inputs]) }
+
+        # For each input signature, find the most common tool call pattern
+        signature_patterns = by_inputs.map do |input_sig, execs|
+          patterns = execs.map { |ex| normalize_tool_calls(ex[:tool_calls]) }
+          pattern_counts = patterns.tally
+          most_common = pattern_counts.max_by { |_, count| count }
+
+          {
+            input_signature: input_sig,
+            total_executions: execs.size,
+            most_common_pattern: most_common[0],
+            pattern_count: most_common[1],
+            consistency: most_common[1].to_f / execs.size
+          }
+        end
+
+        # Overall consistency is weighted average across input signatures
+        total_execs = executions.size
+        weighted_consistency = signature_patterns.sum do |sig_data|
+          weight = sig_data[:total_executions].to_f / total_execs
+          weight * sig_data[:consistency]
+        end
+
+        # Find the globally most common pattern
+        all_patterns = signature_patterns.map { |s| s[:most_common_pattern] }
+        common_pattern = all_patterns.max_by { |p| all_patterns.count(p) }
+
+        {
+          score: weighted_consistency.round(3),
+          common_pattern: common_pattern,
+          input_signatures: signature_patterns.size
+        }
+      end
+
+      private
+
+      # Detect and initialize the appropriate backend adapter
+      #
+      # Auto-detection order: SigNoz → Jaeger → Tempo
+      # Falls back to nil if no backend is available
+      #
+      # @return [BaseAdapter, nil] Initialized adapter or nil
+      def detect_backend_adapter
+        return nil unless @endpoint
+
+        # Explicit backend selection
+        if @backend_type
+          adapter = create_adapter(@backend_type)
+          return adapter if adapter
+
+          @logger.warn("Requested backend '#{@backend_type}' not available, trying auto-detection")
+        end
+
+        # Auto-detect with fallback chain
+        %w[signoz jaeger tempo].each do |backend|
+          adapter = create_adapter(backend)
+          if adapter
+            @logger.info("Detected OTLP backend: #{backend} at #{@endpoint}")
+            return adapter
+          end
+        end
+
+        @logger.warn("No OTLP backend available at #{@endpoint}, learning disabled")
+        nil
+      end
+
+      # Create adapter instance for specified backend
+      #
+      # @param backend_type [String] Backend type
+      # @return [BaseAdapter, nil] Adapter instance or nil if unavailable
+      def create_adapter(backend_type)
+        require_relative "adapters/#{backend_type}_adapter"
+
+        adapter_class = case backend_type.downcase
+                        when 'signoz'
+                          Adapters::SignozAdapter
+                        when 'jaeger'
+                          Adapters::JaegerAdapter
+                        when 'tempo'
+                          Adapters::TempoAdapter
+                        else
+                          @logger.error("Unknown backend type: #{backend_type}")
+                          return nil
+                        end
+
+        return nil unless adapter_class.available?(@endpoint, @api_key)
+
+        adapter_class.new(@endpoint, @api_key, logger: @logger)
+      rescue LoadError => e
+        @logger.debug("Adapter #{backend_type} not available: #{e.message}")
+        nil
+      rescue StandardError => e
+        @logger.error("Failed to create #{backend_type} adapter: #{e.message}")
+        nil
+      end
+
+      # Normalize time range to Range<Time>
+      #
+      # @param time_range [Integer, Range<Time>] Time range
+      # @return [Range<Time>] Normalized time range
+      def normalize_time_range(time_range)
+        case time_range
+        when Range
+          time_range
+        when Integer
+          (Time.now - time_range)..Time.now
+        else
+          (Time.now - DEFAULT_TIME_RANGE)..Time.now
+        end
+      end
+
+      # Normalize inputs for comparison
+      #
+      # @param inputs [Hash] Task inputs
+      # @return [String] Normalized input signature
+      def normalize_inputs(inputs)
+        return '' unless inputs.is_a?(Hash)
+
+        inputs.sort.to_h.to_s
+      end
+
+      # Normalize tool calls for pattern matching
+      #
+      # @param tool_calls [Array<Hash>] Tool call sequence
+      # @return [String] Normalized pattern signature
+      def normalize_tool_calls(tool_calls)
+        return '' unless tool_calls.is_a?(Array)
+
+        tool_calls.map { |tc| tc[:tool_name] }.join(' → ')
+      end
+    end
+  end
+end

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.58
+  :version: 0.1.61
   :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.58",
+  "version": "0.1.61",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/templates/task_synthesis.tmpl

@@ -0,0 +1,98 @@
+You are analyzing whether an agentic task can be converted to symbolic Ruby code.
+
+## What "Symbolic" Means
+
+A task is **symbolic** (can be optimized) if it follows a predictable algorithm:
+- Reading files, calling APIs, transforming data = SYMBOLIC (even though outputs vary based on data)
+- The same code logic applies regardless of the actual data values
+- Conditional branches based on data (if file exists, if value > threshold) are fine
+
+A task is **neural** (cannot be optimized) only if it requires:
+- Creative text generation (writing stories, poems, marketing copy)
+- Subjective reasoning or judgment calls
+- Understanding nuanced human intent that varies per request
+
+**Key insight:** File I/O, API calls, and data transformation are deterministic CODE even if their outputs depend on external state. "Read a file and count lines" is symbolic - the algorithm is fixed.
+
+## Task Definition
+
+**Name:** {{.TaskName}}
+**Instructions:** {{.Instructions}}
+
+**Inputs:**
+{{.Inputs}}
+
+**Outputs:**
+{{.Outputs}}
+
+## Current Task Code
+
+```ruby
+{{.TaskCode}}
+```
+
+## Execution Traces ({{.TraceCount}} samples)
+
+{{.Traces}}
+
+## Pattern Analysis
+
+- **Most Common Pattern:** {{.CommonPattern}}
+- **Pattern Consistency:** {{.ConsistencyScore}}%
+- **Unique Patterns Observed:** {{.UniquePatternCount}}
+
+## Available Tools
+
+{{.ToolsList}}
+
+---
+
+## Your Task
+
+Analyze whether this neural task can be converted to symbolic Ruby code.
+
+Questions to ask:
+1. Is there a clear algorithm implied by the instructions?
+2. Do the tool call patterns show a logical sequence?
+3. Can conditional logic handle the variations seen in traces?
+
+Tasks that ARE symbolic (optimize these):
+- "Read file X and return its contents" → read_file, return content
+- "Check if file exists, create if not" → get_file_info, conditional write_file
+- "Fetch data from API and transform it" → api_call, data transformation
+
+Tasks that are NOT symbolic (don't optimize):
+- "Write a creative story continuation"
+- "Decide what the user probably meant"
+- "Generate marketing copy for this product"
+
+## Output Format
+
+Respond with valid JSON:
+
+```json
+{
+  "is_deterministic": true/false,
+  "confidence": 0.0-1.0,
+  "explanation": "Brief explanation",
+  "code": "Ruby code if symbolic, null otherwise"
+}
+```
+
+**Code Requirements (if symbolic):**
+- Use the DSL task format with a do block:
+  ```ruby
+  task :task_name,
+       instructions: "Keep the original instructions for documentation",
+       inputs: { ... },
+       outputs: { ... } do |inputs|
+    # Helper methods available: execute_tool, execute_task, execute_llm
+    result = execute_tool(:tool_name, { arg: value })
+    { output_key: result }
+  end
+  ```
+- Use `execute_tool(:tool_name, { arg: value })` for MCP tool calls
+- Use `execute_task(:task_name, inputs: { ... })` to call other tasks
+- Access inputs via the `inputs` hash parameter
+- Return a hash matching the output schema
+- Do NOT use system(), eval(), or other unsafe methods

data/lib/language_operator/ux/concerns/provider_helpers.rb

@@ -156,8 +156,8 @@ module LanguageOperator
           data = JSON.parse(response.body)
           models = data['data']&.map { |m| m['id'] } || []
 
-          # Filter out fine-tuned/snapshot models for better UX
-          models.reject { |m| m.include?('ft-') || m.include?(':') }
+          # Filter out fine-tuned models for better UX
+          models.reject { |m| m.include?('ft-') }
         rescue StandardError
           nil
         end

data/lib/language_operator/version.rb

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

data/synth/003/Makefile

@@ -1,6 +1,6 @@
 .PHONY: create code logs clean
 
-AGENT := synth-003
+AGENT := s003
 AICTL := bundle exec ../../bin/aictl agent
 TOOLS := workspace
 
@@ -8,11 +8,18 @@ create:
 	cat agent.txt | $(AICTL) create --name $(AGENT) --tools "$(TOOLS)"
 
 run:
-	kubectl create job --from=cronjob/$(AGENT) $(AGENT)-manual
+	@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)
 
+optimize:
+	$(AICTL) optimize $(AGENT)
+
 logs:
 	$(AICTL) logs $(AGENT)
 
@@ -21,4 +28,4 @@ clean:
 
 save:
 	$(AICTL) code $(AGENT) --raw > agent.rb
-	$(AICTL) logs $(AGENT) > output.log
+	$(AICTL) logs $(AGENT) > output.log

data/synth/003/output.log

@@ -0,0 +1,68 @@
+⚬ OpenTelemetry enabled
+Waiting for tool at localhost:80...
+Tool ready at localhost:80
+⚬ Configuring LLM (provider=openai_compatible, model=mistralai/magistral-small-2509, timeout=300)
+⚬ LLM configuration complete
+⚬ Connecting to MCP servers (count=1)
+⚬ Successfully connected to MCP server (server=default-tools-0)
+⚬ MCP server connected (server=default-tools-0, tool_count=6, tools=["read_file", "write_file", "list_directory", "create_directory", "get_file_info", "search_files"])
+⚬ MCP connection summary (connected_servers=1, total_tools=6)
+⚬ Chat session initialized (with_tools=true)
+⚬ Agent running in scheduled mode - executing once (agent_name=synth-003, dsl_version=v1)
+⚬ Executing main block (agent=synth-003, task_count=3)
+⚬ Executing main block (inputs_keys=[])
+⚬ Executing task (task=read_existing_story, type=neural, timeout=360.0, max_retries=3)
+⚬ Sending prompt to LLM (task=read_existing_story, prompt_length=572, available_tools=["read_file", "write_file", "list_directory", "create_directory", "get_file_info", "search_files"])
+⚬ Tool call initiated by LLM (event=tool_call_initiated, tool_name=get_file_info, tool_id=617083832, arguments={"path" => "story.txt"}, arguments_json={"path":"story.txt"})
+⚬ Tool call result received (event=tool_result_received, result=Path: story.txt
+Type: file
+Size: 200 B
+Permissions: 664
+Owner UID: 1000
+Owner GID: 101
+Created: 2025-11-19 02:00:00 +0000
+Modified: 2025-11-19 01:45:12 +0000
+Accessed: 2025-11-19 02:07:30 +0000, result_preview=Path: story.txt
+Type: file
+Size: 200 B
+Permissions: 664
+Owner UID: 1000
+Owner GID: 101
+Created: 20...)
+⚬ Tool call initiated by LLM (event=tool_call_initiated, tool_name=read_file, tool_id=783124383, arguments={"path" => "story.txt"}, arguments_json={"path":"story.txt"})
+⚬ Tool call result received (event=tool_result_received, result=Once upon a time, in a quiet village nestled between rolling hills, there lived a young girl named Lily.
+One day, while playing near the edge of the forest, she discovered a mysterious glowing flower., result_preview=Once upon a time, in a quiet village nestled between rolling hills, there lived a young girl named...)
+⚬ LLM response received, extracting content (task=read_existing_story, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=read_existing_story, response_length=592)
+⚬ Parsing neural task response (task=read_existing_story)
+⚬ LLM thinking captured (event=llm_thinking, task=read_existing_story, thinking_steps=1, thinking=["Now that I have the content, I need to count the number of sentences by splitting it by newline. The content is a single line, so there's only one sentence.\n\nBut wait, the problem says to split by newline. The content is a single line, so sentence_count should be 1.\n\nNow, I'll prepare the JSON response with the content and sentence count."], thinking_preview=Now that I have the content, I need to count the number of sentences by splitting it by newline. T...)
+⚬ Response parsed successfully (task=read_existing_story, output_keys=[:content, :sentence_count])
+⚬ Validating task outputs (task=read_existing_story)
+⚬ Executing task (task=generate_next_sentence, type=neural, timeout=360.0, max_retries=3)
+⚬ Sending prompt to LLM (task=generate_next_sentence, prompt_length=773, available_tools=["read_file", "write_file", "list_directory", "create_directory", "get_file_info", "search_files"])
+E, [2025-11-19T02:10:54.380136 #7] ERROR -- : OpenTelemetry error: Unable to export 4 spans
+⚬ LLM response received, extracting content (task=generate_next_sentence, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=generate_next_sentence, response_length=824)
+⚬ Parsing neural task response (task=generate_next_sentence)
+⚬ LLM thinking captured (event=llm_thinking, task=generate_next_sentence, thinking_steps=1, thinking=["The existing content has two sentences. The story is in a fairy tale style, so the next sentence should continue in that tone.\n\nThe first sentence sets up the setting and character. The second introduces a key event (the glowing flower). A natural continuation might be that Lily decides to pick the flower or something happens when she touches it.\n\nLet me draft a possible next sentence: \"As she reached out to touch the flower, it suddenly let out a soft humming sound.\"\n\nNow, I need to ensure that this is exactly one sentence and maintains the tone.\n\nLet me confirm it's a complete sentence with proper punctuation. It is, and it fits the fairy tale style.\n\nNow, prepare the JSON response with this sentence."], thinking_preview=The existing content has two sentences. The story is in a fairy tale style, so the next sentence s...)
+⚬ Response parsed successfully (task=generate_next_sentence, output_keys=[:sentence])
+⚬ Validating task outputs (task=generate_next_sentence)
+⚬ Executing task (task=append_to_story, type=neural, timeout=360.0, max_retries=3)
+⚬ Sending prompt to LLM (task=append_to_story, prompt_length=684, available_tools=["read_file", "write_file", "list_directory", "create_directory", "get_file_info", "search_files"])
+E, [2025-11-19T02:11:09.382616 #7] ERROR -- : OpenTelemetry error: Unable to export 4 spans
+⚬ Tool call initiated by LLM (event=tool_call_initiated, tool_name=read_file, tool_id=982459012, arguments={"path" => "story.txt"}, arguments_json={"path":"story.txt"})
+⚬ Tool call result received (event=tool_result_received, result=Once upon a time, in a quiet village nestled between rolling hills, there lived a young girl named Lily.
+One day, while playing near the edge of the forest, she discovered a mysterious glowing flower., result_preview=Once upon a time, in a quiet village nestled between rolling hills, there lived a young girl named...)
+⚬ Tool call initiated by LLM (event=tool_call_initiated, tool_name=write_file, tool_id=433722466, arguments={"path" => "story.txt", "content" => "Once upon a time, in a quiet village nestled between rolling hills, there lived a young girl named Lily.\nOne day, while playing near the edge of the forest, she discovered a mysterious glowing flower.\nAs she reached out to touch the flower, it suddenly let out a soft humming sound."}, arguments_json={"path":"story.txt","content":"Once upon a time, in a quiet village nestled between rolling hills,...)
+⚬ Tool call result received (event=tool_result_received, result=Successfully wrote 282 bytes to story.txt, result_preview=Successfully wrote 282 bytes to story.txt)
+⚬ LLM response received, extracting content (task=append_to_story, response_class=RubyLLM::Message, has_tool_calls=, tool_call_count=0)
+⚬ Neural task response received (task=append_to_story, response_length=39)
+⚬ Parsing neural task response (task=append_to_story)
+⚬ Response parsed successfully (task=append_to_story, output_keys=[:success, :total_sentences])
+⚬ Validating task outputs (task=append_to_story)
+⚬ Main execution (71.111s)
+⚬ Main block completed
+⚬ Main block execution completed (result={added_sentence: "As she reached out to touch the flower, it suddenly let out a soft humming sound.", total_sentences: 3})
+Added sentence: As she reached out to touch the flower, it suddenly let out a soft humming sound.
+Story now has 3 sentences
+⚬ Scheduled execution completed - exiting (agent_name=synth-003)

data/synth/README.md

@@ -1,5 +1,3 @@
 # Synthesis Tests
 
-Canonical "hey this might actually work" synthesis suite.
-
-Model: [Magistral-Small-2509](https://huggingface.co/mistralai/Magistral-Small-2509) 4bit MLX
+Canonical "hey this might actually work" synthesis suite.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.58
+  version: 0.1.61
 platform: ruby
 authors:
 - James Ryan
@@ -474,6 +474,7 @@ files:
 - lib/language_operator/cli/formatters/code_formatter.rb
 - lib/language_operator/cli/formatters/log_formatter.rb
 - lib/language_operator/cli/formatters/log_style.rb
+- lib/language_operator/cli/formatters/optimization_formatter.rb
 - lib/language_operator/cli/formatters/progress_formatter.rb
 - lib/language_operator/cli/formatters/status_formatter.rb
 - lib/language_operator/cli/formatters/table_formatter.rb
@@ -524,6 +525,14 @@ files:
 - lib/language_operator/instrumentation/task_tracer.rb
 - lib/language_operator/kubernetes/client.rb
 - lib/language_operator/kubernetes/resource_builder.rb
+- lib/language_operator/learning/adapters/base_adapter.rb
+- lib/language_operator/learning/adapters/jaeger_adapter.rb
+- lib/language_operator/learning/adapters/signoz_adapter.rb
+- lib/language_operator/learning/adapters/tempo_adapter.rb
+- lib/language_operator/learning/optimizer.rb
+- lib/language_operator/learning/pattern_detector.rb
+- lib/language_operator/learning/task_synthesizer.rb
+- lib/language_operator/learning/trace_analyzer.rb
 - lib/language_operator/loggable.rb
 - lib/language_operator/logger.rb
 - lib/language_operator/retry.rb
@@ -535,6 +544,7 @@ files:
 - lib/language_operator/templates/schema/CHANGELOG.md
 - lib/language_operator/templates/schema/agent_dsl_openapi.yaml
 - lib/language_operator/templates/schema/agent_dsl_schema.json
+- lib/language_operator/templates/task_synthesis.tmpl
 - lib/language_operator/tool_loader.rb
 - lib/language_operator/type_coercion.rb
 - lib/language_operator/ux/base.rb
@@ -561,6 +571,7 @@ files:
 - synth/003/README.md
 - synth/003/agent.rb
 - synth/003/agent.txt
+- synth/003/output.log
 - synth/README.md
 homepage: https://github.com/language-operator/language-operator
 licenses: