language-operator 0.1.52 → 0.1.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11e9d5df0ee7675d0e0f2bccbc2fcb9eaee376e5ad9f7d11a8d8f0000c994bb2
-  data.tar.gz: 0d8ac88a87ac9037934084d3e616ab1107e4e4fa26ae138809e7c64ca6924ca1
+  metadata.gz: cc9f8e717ca6bd8f00386094494b88f2f2e3050239b9d476ba9519868d82df58
+  data.tar.gz: b15364fd16e4a9793263a8d861999d3c0a9188c2db3c6122176462a6b934c753
 SHA512:
-  metadata.gz: 452afc411ecdf258e31636750e63305b682a89dd07039071e5b43d68b2de2d37ecde1a5d2b362a2a96d28bc3f934dfd5fd90df54c483e0321ba46f5bff3aa037
-  data.tar.gz: 0fd49b16dc6b2db57ee1be9a165bfbe9e5eecccb6051cde1ed8d417caf2ca0949160ad357f516603a9f8afdfc300e8432fd5e9c96b88bf3f4fcca8fd149d00b0
+  metadata.gz: 62729e36597f476b960c64b589a2e426ef5fe54f51e7db91d0ab91cdbc05a916fc000bc94c1e828e9839e2f6bff95a31f42f3c330006a008bc9c1e2a2fd63e03
+  data.tar.gz: a5472ea444b2d6bf58316c638b03b22365bd51e6b635a3eb3b2cb2d458a540e802def9e7d86243ec72bf958924b1c4441485ea8cf9121c7d96647a9bf046cec9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.52)
+    language-operator (0.1.54)
       faraday (~> 2.0)
       k8s-ruby (~> 0.17)
       mcp (~> 0.4)
@@ -17,7 +17,6 @@ PATH
       rouge (~> 4.0)
       ruby_llm (~> 1.8)
       ruby_llm-mcp (~> 0.1)
-      rufus-scheduler (~> 3.9)
       thor (~> 1.3)
       tty-prompt (~> 0.23)
       tty-spinner (~> 0.9)
@@ -62,8 +61,6 @@ GEM
       dry-inflector (~> 1.0)
       dry-logic (~> 1.4)
       zeitwerk (~> 2.6)
-    et-orbi (1.4.0)
-      tzinfo
     event_stream_parser (1.0.0)
     excon (0.112.0)
     faraday (2.14.0)
@@ -76,9 +73,6 @@ GEM
       net-http (>= 0.5.0)
     faraday-retry (2.3.2)
       faraday (~> 2.0)
-    fugit (1.12.1)
-      et-orbi (~> 1.4)
-      raabro (~> 1.4)
     google-protobuf (4.33.0)
       bigdecimal
       rake (>= 13)
@@ -164,7 +158,6 @@ GEM
     public_suffix (6.0.2)
     puma (6.6.1)
       nio4r (~> 2.0)
-    raabro (1.4.0)
     racc (1.8.1)
     rack (3.2.4)
     rack-test (2.2.0)
@@ -226,8 +219,6 @@ GEM
       ruby_llm (~> 1.9)
       zeitwerk (~> 2)
     ruby_llm-schema (0.2.1)
-    rufus-scheduler (3.9.2)
-      fugit (~> 1.1, >= 1.11.1)
     strings (0.2.1)
       strings-ansi (~> 0.2)
       unicode-display_width (>= 1.5, < 3.0)
@@ -250,8 +241,6 @@ GEM
       pastel (~> 0.8)
       strings (~> 0.2.0)
       tty-screen (~> 0.8)
-    tzinfo (2.0.6)
-      concurrent-ruby (~> 1.0)
     unicode-display_width (2.6.0)
     unicode_utils (1.4.0)
     uri (1.1.1)

data/lib/language_operator/agent/base.rb

@@ -37,7 +37,6 @@ module LanguageOperator
         @workspace_path = ENV.fetch('WORKSPACE_PATH', '/workspace')
         @mode = ENV.fetch('AGENT_MODE', 'autonomous')
         @executor = nil
-        @scheduler = nil
       end
 
       # Run the agent in its configured mode
@@ -93,12 +92,16 @@ module LanguageOperator
         @executor.run_loop
       end
 
-      # Run in scheduled mode
+      # Run in scheduled mode (execute once - Kubernetes CronJob handles scheduling)
       #
       # @return [void]
       def run_scheduled
-        @scheduler = Scheduler.new(self)
-        @scheduler.start
+        logger.info('Agent running in scheduled mode without definition - executing goal once')
+
+        goal = ENV.fetch('AGENT_INSTRUCTIONS', 'Complete the assigned task')
+        execute_goal(goal)
+
+        logger.info('Scheduled execution completed - exiting')
       end
 
       # Run in reactive mode (HTTP server)

data/lib/language_operator/agent.rb

@@ -3,7 +3,6 @@
 require_relative 'agent/base'
 require_relative 'agent/executor'
 require_relative 'agent/task_executor'
-require_relative 'agent/scheduler'
 require_relative 'agent/web_server'
 require_relative 'dsl'
 require_relative 'logger'
@@ -147,6 +146,7 @@ module LanguageOperator
     # @param agent [LanguageOperator::Agent::Base] The agent instance
     # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
     # @return [void]
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
     def self.run_with_definition(agent, agent_def)
       agent.connect!
 
@@ -167,17 +167,24 @@ module LanguageOperator
           raise 'Agent definition must have either main block (DSL v1) or workflow (DSL v0)'
         end
       when 'scheduled', 'event-driven'
+        # Scheduled mode: Execute once and exit (Kubernetes CronJob handles scheduling)
+        logger.info('Agent running in scheduled mode - executing once',
+                    agent_name: agent_def.name,
+                    dsl_version: uses_dsl_v1 ? 'v1' : 'v0')
+
         if uses_dsl_v1
-          # DSL v1: Schedule main block execution
-          scheduler = LanguageOperator::Agent::Scheduler.new(agent)
-          scheduler.start_with_main(agent_def)
+          # DSL v1: Execute main block once
+          execute_main_block(agent, agent_def)
         elsif uses_dsl_v0
-          # DSL v0: Schedule workflow execution
-          scheduler = LanguageOperator::Agent::Scheduler.new(agent)
-          scheduler.start_with_workflow(agent_def)
+          # DSL v0: Execute workflow once
+          executor = LanguageOperator::Agent::Executor.new(agent)
+          executor.execute_workflow(agent_def)
         else
           raise 'Agent definition must have either main block (DSL v1) or workflow (DSL v0)'
         end
+
+        logger.info('Scheduled execution completed - exiting',
+                    agent_name: agent_def.name)
       when 'reactive', 'http', 'webhook'
         # Start web server with webhooks, MCP tools, and chat endpoint
         web_server = LanguageOperator::Agent::WebServer.new(agent)
@@ -189,6 +196,7 @@ module LanguageOperator
         raise "Unknown agent mode: #{agent.mode}"
       end
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
     # Execute main block (DSL v1) in autonomous mode
     #

data/lib/language_operator/dsl/agent_definition.rb

@@ -357,24 +357,6 @@ module LanguageOperator
         "Agent:#{@name}"
       end
 
-      def run_scheduled
-        require 'rufus-scheduler'
-
-        scheduler = Rufus::Scheduler.new
-
-        logger.info('Scheduling agent',
-                    name: @name,
-                    cron: @schedule)
-
-        scheduler.cron(@schedule) do
-          logger.timed('Scheduled execution') do
-            execute_objectives
-          end
-        end
-
-        scheduler.join
-      end
-
       def run_autonomous
         logger.info('Running agent in autonomous mode', name: @name)
         execute_objectives

data/lib/language_operator/templates/agent_synthesis.tmpl

@@ -77,8 +77,8 @@ This is attempt {{.AttemptNumber}} of {{.MaxAttempts}}. The user is counting on
 
 **Runtime Context:**
 - All agent messages and output are automatically logged to stdout
-- Agents have access to a workspace directory for file operations
 - LLM responses are captured and available in agent execution context
+- File operations should use neural tasks that delegate to the workspace tool (see examples below)
 
 ## DSL v1 Reference Examples
 
@@ -174,16 +174,72 @@ agent "data-pipeline" do
 
   main do |inputs|
     extracted = execute_task(:extract_data, inputs: inputs)
-    transformed = execute_task(:transform_data, inputs: extracted)
+    transformed = execute_task(:transform_data, inputs: transformed)
     result = execute_task(:load_data, inputs: transformed)
     result
   end
 end
 ```
 
+### Example 4: Stateful Agent with Workspace File Operations
+```ruby
+require 'language_operator'
+
+agent "story-builder" do
+  description "Build a story one sentence at a time"
+  mode :scheduled
+  schedule "0 * * * *"
+
+  # Neural task - LLM reads file using workspace tool
+  task :read_existing_story,
+    instructions: "Read the story.txt file from workspace. If it doesn't exist, return empty string. Return the content and count of sentences.",
+    inputs: {},
+    outputs: { content: 'string', sentence_count: 'integer' }
+
+  # Neural task - LLM generates creative continuation
+  task :generate_next_sentence,
+    instructions: "Generate exactly one new sentence to continue this story. Maintain consistent tone and style. Only output the new sentence.",
+    inputs: { existing_content: 'string' },
+    outputs: { sentence: 'string' }
+
+  # Neural task - LLM writes file using workspace tool
+  task :append_to_story,
+    instructions: "Append the new sentence to story.txt in workspace. If the file has existing content, add a newline first.",
+    inputs: { sentence: 'string' },
+    outputs: { success: 'boolean', total_sentences: 'integer' }
+
+  main do |inputs|
+    # Read current state from workspace
+    story_data = execute_task(:read_existing_story)
+
+    # Generate new content based on what exists
+    new_sentence = execute_task(:generate_next_sentence,
+                                inputs: { existing_content: story_data[:content] })
+
+    # Persist to workspace for next run
+    result = execute_task(:append_to_story,
+                         inputs: { sentence: new_sentence[:sentence] })
+
+    { sentence: new_sentence[:sentence], total: result[:total_sentences] }
+  end
+
+  output do |outputs|
+    puts "Added sentence: #{outputs[:sentence]}"
+    puts "Story now has #{outputs[:total]} sentences"
+  end
+end
+```
+
+**File Operations Best Practices:**
+- **NEVER** use direct Ruby file operations (`File.read`, `File.write`, `File.open`, `Dir.pwd`, etc.) in agent code
+- **ALWAYS** delegate file operations to neural tasks with clear natural language instructions
+- File operations require the LLM to reason about paths, content, and state - use the workspace tool via neural tasks
+- The workspace tool provides: `read_file`, `write_file`, `list_directory`, `create_directory`, `get_file_info`, `search_files`
+- Example pattern: `task :read_data, instructions: "read data.json from workspace and parse it", inputs: {}, outputs: { data: 'hash' }`
+
 ## Your Task: Generate DSL v1 Agent
 
-Using the THREE CONCRETE EXAMPLES above (daily-report, code-reviewer, data-pipeline) as reference patterns, generate WORKING Ruby DSL code for the agent described in the user instructions.
+Using the FOUR CONCRETE EXAMPLES above (daily-report, code-reviewer, data-pipeline, story-builder) as reference patterns, generate WORKING Ruby DSL code for the agent described in the user instructions.
 
 **CRITICAL REQUIREMENTS:**
 - DO NOT output placeholder text like "Brief description extracted from instructions" or "CRON_EXPRESSION"
@@ -250,6 +306,9 @@ end
 - ✓ Are all task names, descriptions, and logic SPECIFIC to the user's request?
 - ✓ Did you AVOID outputting placeholders like "task_name" or "CRON_EXPRESSION"?
 - ✓ Does the code actually DO what the user asked for?
+- ✓ Did you use NEURAL TASKS (not symbolic code blocks) for all file operations?
+- ✓ Did you NEVER use File.read, File.write, Dir.pwd, or other direct file APIs?
+- ✓ For workspace operations, did you write clear instructions for the LLM to use the workspace tool?
 
 If you cannot answer YES to all of the above, re-read the user instructions and generate FUNCTIONAL code.
 

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

data/lib/language_operator/version.rb

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

data/synth/002/README.md

@@ -36,16 +36,24 @@ mode :scheduled
 schedule "*/10 * * * *"  # Every 10 minutes
 ```
 
-Validates that agents can run on a schedule using cron syntax:
+Validates that agents can run on a schedule using Kubernetes CronJobs:
 - ✅ **Mode dispatch** - Runtime recognizes `:scheduled` mode
-- ✅ **Cron parsing** - Schedule expression is parsed correctly
-- ✅ **Scheduler integration** - `rufus-scheduler` integration works
-- ✅ **Repeated execution** - Agent runs multiple times automatically
+- ✅ **Cron parsing** - Schedule expression is used by Kubernetes CronJob
+- ✅ **Kubernetes-native** - CronJob creates pods on schedule
+- ✅ **Execute once and exit** - Each pod runs the task once, then terminates
+- ✅ **Repeated execution** - Kubernetes creates new pods per schedule
 
 ### 3. Complete Neural Execution Flow
 ```
 ┌─────────────────────────────────────────────────────────┐
-│  Scheduler Triggers (every 10 minutes)                  │
+│  Kubernetes CronJob Triggers (every 10 minutes)         │
+│  Creates new pod for this execution                     │
+└────────────────────┬────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────┐
+│  Pod Starts → Agent Runtime Loads                       │
+│  Mode: scheduled → Execute once and exit                │
 └────────────────────┬────────────────────────────────────┘
                      │
                      ▼
@@ -75,6 +83,12 @@ Validates that agents can run on a schedule using cron syntax:
 ┌─────────────────────────────────────────────────────────┐
 │  Output Block Processes Result                          │
 │  puts outputs[:fortune]                                 │
+└────────────────────┬────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────┐
+│  Agent Exits → Pod Terminates                           │
+│  Kubernetes waits for next cron schedule                │
 └─────────────────────────────────────────────────────────┘
 ```
 
@@ -133,100 +147,6 @@ This test proves the foundation for learning:
 
 **The critical insight**: Because `execute_task(:generate_fortune)` works the same whether the task is neural or symbolic, we can replace implementations without breaking the `main` block.
 
-### No Other Framework Can Do This
-
-| Framework | Neural Execution | Symbolic Execution | Transparent Evolution |
-|-----------|-----------------|-------------------|---------------------|
-| **Language Operator** | ✅ Instructions-based tasks | ✅ Code blocks | ✅ Contract abstraction |
-| LangChain | ❌ Chains are static | ✅ Python code | ❌ No abstraction |
-| AutoGen | ✅ Conversational | ❌ No symbolic optimization | ❌ No contracts |
-| CrewAI | ✅ Agents with prompts | ❌ No learning | ❌ No abstraction |
-
-## What It Doesn't Test
-
-This test intentionally **does not** validate:
-- ❌ Learning/re-synthesis (future tests)
-- ❌ MCP tool integration in neural tasks (future tests)
-- ❌ Complex multi-task workflows (future tests)
-- ❌ Error recovery and re-synthesis (future tests)
-- ❌ Hybrid neural-symbolic agents (future tests)
-
-## Success Criteria
-
-✅ **Agent synthesizes with neural task** - Instructions-based task definition works
-✅ **Scheduled mode activates** - Agent runs on cron schedule
-✅ **Neural task executes** - LLM is invoked with instructions
-✅ **Output schema validated** - LLM response matches `{ fortune: 'string' }`
-✅ **Output appears** - Fortune is logged to stdout
-✅ **Repeated execution** - Agent runs multiple times (every 10 minutes)
-
-## Connection to DSL v1 Proposal
-
-From [dsl-v1.md](../requirements/proposals/dsl-v1.md):
-
-> **Critical Property:** The caller cannot tell which implementation is used. The contract is the interface.
-
-This test proves that property works in practice:
-
-**Contract (Stable):**
-```ruby
-task :generate_fortune,
-  inputs: {},
-  outputs: { fortune: 'string' }
-```
-
-**Implementation (Neural - for now):**
-```ruby
-instructions: "Generate a random fortune for the user"
-```
-
-**Caller (Unaware):**
-```ruby
-main do |inputs|
-  fortune_data = execute_task(:generate_fortune)  # Works regardless of implementation
-  { fortune: fortune_data[:fortune] }
-end
-```
-
-The `main` block doesn't know (and doesn't care) whether `:generate_fortune` is neural or symbolic. This is the **organic function abstraction** that enables real-time synthesis and learning.
-
-## Running the Test
-
-```bash
-# Execute the synthesized agent
-ruby synth/002/agent.rb
-
-# Expected behavior:
-# - Agent starts in scheduled mode
-# - Every 10 minutes, generates and prints a fortune
-# - Runs continuously until stopped
-```
-
-## What Success Looks Like
-
-```
-[INFO] Loading agent: test-agent
-[INFO] Mode: scheduled (*/10 * * * *)
-[INFO] Scheduler started
-[INFO] Executing main block (scheduled trigger)
-[INFO] Executing task: generate_fortune (neural)
-[INFO] Calling LLM with instructions: "Generate a random fortune for the user"
-[INFO] LLM returned: {:fortune=>"A journey of a thousand miles begins with a single step."}
-[INFO] Validating output schema: { fortune: 'string' } ✓
-[INFO] Task returned: {:fortune=>"A journey of a thousand miles begins with a single step."}
-[INFO] Processing output
-A journey of a thousand miles begins with a single step.
-[INFO] Agent execution complete, waiting for next schedule
-[INFO] Next run: 2025-11-16 14:20:00
-...
-[INFO] Executing main block (scheduled trigger)
-[INFO] Executing task: generate_fortune (neural)
-[INFO] Calling LLM with instructions: "Generate a random fortune for the user"
-[INFO] LLM returned: {:fortune=>"Fortune favors the bold."}
-[INFO] Validating output schema: { fortune: 'string' } ✓
-Fortune favors the bold.
-```
-
 ## The Organic Function In Action
 
 **What makes this revolutionary:**
@@ -237,51 +157,4 @@ Fortune favors the bold.
 4. **Learning Ready**: After N runs, system can observe patterns and synthesize symbolic implementation
 5. **Zero Breaking Changes**: When re-synthesized, `main` block never changes
 
-**This is what "living code" means**: Code that starts neural (flexible, works immediately) and becomes symbolic (fast, cheap) through observation, all while maintaining a stable contract.
-
----
-
-**Status**: ✅ VALIDATED - Neural organic functions work
-
-**Next**: Test 003+ will validate learning, re-synthesis, and progressive neural→symbolic evolution
-
----
-
-## Technical Deep Dive
-
-### How Neural Execution Works
-
-When `execute_task(:generate_fortune)` is called:
-
-1. **Task Lookup**: Runtime finds task definition in agent
-2. **Type Check**: Task has `instructions`, no code block → Neural execution
-3. **Prompt Construction**:
-   ```
-   You are an AI agent executing a task.
-
-   Task: generate_fortune
-   Instructions: Generate a random fortune for the user
-
-   Inputs: {}
-
-   You must return a response matching this schema:
-   { fortune: 'string' }
-
-   [Available tools if any MCP servers connected]
-   ```
-4. **LLM Invocation**: Send prompt to configured LLM (via `ruby_llm`)
-5. **Response Parsing**: Extract structured output from LLM response
-6. **Schema Validation**: Ensure response matches `{ fortune: 'string' }`
-7. **Return**: Validated output returned to caller
-
-### What This Enables Later
-
-Once this works, the learning system can:
-
-1. **Observe Execution**: Collect OpenTelemetry traces showing what the LLM did
-2. **Detect Patterns**: Analyze if LLM behavior is deterministic
-3. **Synthesize Code**: Generate symbolic implementation from observed pattern
-4. **Re-Deploy**: Update ConfigMap with learned code
-5. **Transparent Evolution**: `main` block continues working identically
-
-**This test proves step 1 works** (neural execution). Future tests prove steps 2-5.
+**This is what "living code" means**: Code that starts neural (flexible, works immediately) and becomes symbolic (fast, cheap) through observation, all while maintaining a stable contract.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.52
+  version: 0.1.54
 platform: ruby
 authors:
 - James Ryan
@@ -121,20 +121,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.26'
-- !ruby/object:Gem::Dependency
-  name: rufus-scheduler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.9'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -468,7 +454,6 @@ files:
 - lib/language_operator/agent/safety/manager.rb
 - lib/language_operator/agent/safety/rate_limiter.rb
 - lib/language_operator/agent/safety/safe_executor.rb
-- lib/language_operator/agent/scheduler.rb
 - lib/language_operator/agent/task_executor.rb
 - lib/language_operator/agent/telemetry.rb
 - lib/language_operator/agent/web_server.rb

data/lib/language_operator/agent/scheduler.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-require 'rufus-scheduler'
-require_relative 'executor'
-require_relative 'instrumentation'
-require_relative '../logger'
-require_relative '../loggable'
-
-module LanguageOperator
-  module Agent
-    # Task Scheduler
-    #
-    # Handles scheduled and event-driven task execution using rufus-scheduler.
-    #
-    # @example
-    #   scheduler = Scheduler.new(agent)
-    #   scheduler.start
-    class Scheduler
-      include LanguageOperator::Loggable
-      include LanguageOperator::Agent::Instrumentation
-
-      attr_reader :agent, :rufus_scheduler
-
-      # Initialize the scheduler
-      #
-      # @param agent [LanguageOperator::Agent::Base] The agent instance
-      def initialize(agent)
-        @agent = agent
-        @rufus_scheduler = Rufus::Scheduler.new
-        @executor = Executor.new(agent)
-
-        logger.debug('Scheduler initialized',
-                     workspace: @agent.workspace_path,
-                     servers: @agent.servers_info.length)
-      end
-
-      # Start the scheduler
-      #
-      # @return [void]
-      def start
-        logger.info('Agent starting in scheduled mode')
-        logger.info("Workspace: #{@agent.workspace_path}")
-        logger.info("Connected to #{@agent.servers_info.length} MCP server(s)")
-
-        setup_schedules
-        logger.info('Scheduler started, waiting for scheduled tasks')
-        @rufus_scheduler.join
-      end
-
-      # Start the scheduler with a workflow definition
-      #
-      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition with workflow
-      # @return [void]
-      def start_with_workflow(agent_def)
-        logger.info('Agent starting in scheduled mode with workflow',
-                    agent_name: agent_def.name,
-                    has_workflow: !agent_def.workflow.nil?)
-        logger.info("Workspace: #{@agent.workspace_path}")
-        logger.info("Connected to #{@agent.servers_info.length} MCP server(s)")
-
-        # Extract schedule from agent definition and validate
-        cron_schedule = agent_def.schedule
-        if cron_schedule.nil? || cron_schedule.empty?
-          raise ArgumentError,
-                "Schedule required for scheduled mode agent '#{agent_def.name}'. " \
-                'Use schedule() method to provide a cron expression.'
-        end
-
-        logger.info('Scheduling workflow', cron: cron_schedule, agent: agent_def.name)
-
-        @rufus_scheduler.cron(cron_schedule) do
-          with_span('agent.scheduler.execute', attributes: {
-                      'scheduler.cron_expression' => cron_schedule,
-                      'agent.name' => agent_def.name,
-                      'scheduler.task_type' => 'workflow'
-                    }) do
-            logger.timed('Scheduled workflow execution') do
-              logger.info('Executing scheduled workflow', agent: agent_def.name)
-              result = @executor.execute_workflow(agent_def)
-              result_text = result.is_a?(String) ? result : result.content
-              preview = result_text[0..200]
-              preview += '...' if result_text.length > 200
-              logger.info('Workflow completed', result_preview: preview)
-            end
-          end
-        end
-
-        logger.info('Scheduler started, waiting for scheduled tasks')
-        @rufus_scheduler.join
-      end
-
-      # Start the scheduler with a main block (DSL v1)
-      #
-      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition with main block
-      # @return [void]
-      def start_with_main(agent_def)
-        logger.info('Agent starting in scheduled mode with main block',
-                    agent_name: agent_def.name,
-                    task_count: agent_def.tasks.size)
-        logger.info("Workspace: #{@agent.workspace_path}")
-        logger.info("Connected to #{@agent.servers_info.length} MCP server(s)")
-
-        # Extract schedule from agent definition and validate
-        cron_schedule = agent_def.schedule
-        if cron_schedule.nil? || cron_schedule.empty?
-          raise ArgumentError,
-                "Schedule required for scheduled mode agent '#{agent_def.name}'. " \
-                'Use schedule() method to provide a cron expression.'
-        end
-
-        logger.info('Scheduling main block execution', cron: cron_schedule, agent: agent_def.name)
-
-        # Create task executor with constraints config
-        require_relative 'task_executor'
-        config = build_executor_config(agent_def)
-        task_executor = TaskExecutor.new(@agent, agent_def.tasks, config)
-
-        @rufus_scheduler.cron(cron_schedule) do
-          with_span('agent.scheduler.execute', attributes: {
-                      'scheduler.cron_expression' => cron_schedule,
-                      'agent.name' => agent_def.name,
-                      'scheduler.task_type' => 'main_block'
-                    }) do
-            logger.timed('Scheduled main block execution') do
-              logger.info('Executing scheduled main block', agent: agent_def.name)
-
-              # Get inputs from environment or default to empty hash
-              inputs = {}
-
-              # Execute main block
-              result = agent_def.main.call(inputs, task_executor)
-
-              logger.info('Main block completed', result: result)
-            end
-          end
-        end
-
-        logger.info('Scheduler started, waiting for scheduled tasks')
-        @rufus_scheduler.join
-      end
-
-      # Stop the scheduler
-      #
-      # @return [void]
-      def stop
-        logger.info('Shutting down scheduler')
-        @rufus_scheduler.shutdown
-        logger.info('Scheduler stopped')
-      end
-
-      private
-
-      def logger_component
-        'Agent::Scheduler'
-      end
-
-      # Setup schedules from config
-      #
-      # @return [void]
-      def setup_schedules
-        schedules = @agent.config.dig('agent', 'schedules') || []
-
-        logger.debug('Loading schedules from config', count: schedules.length)
-
-        if schedules.empty?
-          logger.warn('No schedules configured, using default daily schedule')
-          setup_default_schedule
-          return
-        end
-
-        schedules.each do |schedule|
-          add_schedule(schedule)
-        end
-
-        logger.info("#{schedules.length} schedule(s) configured")
-      end
-
-      # Add a single schedule
-      #
-      # @param schedule [Hash] Schedule configuration
-      # @return [void]
-      def add_schedule(schedule)
-        cron = schedule['cron']
-        task = schedule['task']
-        agent_name = @agent.config.dig('agent', 'name')
-
-        logger.info('Scheduling task', cron: cron, task: task[0..100])
-
-        @rufus_scheduler.cron(cron) do
-          with_span('agent.scheduler.execute', attributes: {
-                      'scheduler.cron_expression' => cron,
-                      'agent.name' => agent_name,
-                      'scheduler.task_type' => 'scheduled'
-                    }) do
-            logger.timed('Scheduled task execution') do
-              logger.info('Executing scheduled task', task: task[0..100])
-              result = @executor.execute(task)
-              preview = result[0..200]
-              preview += '...' if result.length > 200
-              logger.info('Task completed', result_preview: preview)
-            end
-          end
-        end
-      end
-
-      # Setup default daily schedule
-      #
-      # @return [void]
-      def setup_default_schedule
-        instructions = @agent.config.dig('agent', 'instructions') ||
-                       'Check for updates and report status'
-        agent_name = @agent.config.dig('agent', 'name')
-        cron = '0 6 * * *'
-
-        logger.info('Setting up default schedule', cron: cron,
-                                                   instructions: instructions[0..100])
-
-        @rufus_scheduler.cron(cron) do
-          with_span('agent.scheduler.execute', attributes: {
-                      'scheduler.cron_expression' => cron,
-                      'agent.name' => agent_name,
-                      'scheduler.task_type' => 'default'
-                    }) do
-            logger.timed('Daily task execution') do
-              logger.info('Executing daily task')
-              result = @executor.execute(instructions)
-              preview = result[0..200]
-              preview += '...' if result.length > 200
-              logger.info('Daily task completed', result_preview: preview)
-            end
-          end
-        end
-
-        logger.info('Scheduled: Daily at 6:00 AM')
-      end
-
-      # Build executor configuration from agent definition constraints
-      #
-      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
-      # @return [Hash] Executor configuration
-      def build_executor_config(agent_def)
-        config = {}
-
-        if agent_def.constraints
-          config[:timeout] = agent_def.constraints[:timeout] if agent_def.constraints[:timeout]
-          config[:max_retries] = agent_def.constraints[:max_retries] if agent_def.constraints[:max_retries]
-        end
-
-        config
-      end
-    end
-  end
-end