language-operator 0.1.55 → 0.1.56

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8f659d81bffc80250db041ffe9aad7b22618c0ed7cfe93836adc248010295ad
-  data.tar.gz: d4364c0cd5cd8c7f3d8f009d5ddf9665a328f9a82c1ddbf9fbdb5c3c95ff791b
+  metadata.gz: ac246ba1f01262701f8e193f697a2df7753f23f376c71a8cbfc24ab87a59e088
+  data.tar.gz: b75afe1475935a9b9ccbe3cd717d46e5b180ba123818fc53ff954f228f5663c8
 SHA512:
-  metadata.gz: 9131e2a4882cf617ef92724dd2c90a1133203c25e1aac1c89b7f7b28baf77d05c4347f98cf901f4c39c2423713140142f01887f5b3698285d19c8694564bdd14
-  data.tar.gz: 3f11916df339b3a605287db9ad38794642d6e843c42710354b5c09e34b10fa12ce94012a793127a1ef7ad4ffdb400656b10f33afb764e05683b341a6dca2109e
+  metadata.gz: d66f44b6d599faaf6c0d93368ff03a50f50372c0924ad8b85f387c842c0302fa5e31c37472dbe484236fc917957ed33a2fa8b80502df0605a1d91909a5613b80
+  data.tar.gz: 727ac1463af4516edcc552582909f77351f913fbdad2ae260bcc62f1f0f058006cf56dbb71ccd4910ec0f63aeb41ec7c812ea2ab3ee8f413dab5e620443cd5a1

data/.rubocop.yml

@@ -9,6 +9,7 @@ AllCops:
     - 'tmp/**/*'
     - 'bin/bump-version'
     - 'lib/language_operator/cli/templates/**/*'
+    - 'synth/**/*'
 
 # Metrics
 Metrics/BlockLength:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.55)
+    language-operator (0.1.56)
       faraday (~> 2.0)
       k8s-ruby (~> 0.17)
       mcp (~> 0.4)

data/lib/language_operator/cli/commands/agent.rb

@@ -48,8 +48,11 @@ module LanguageOperator
         option :wizard, type: :boolean, default: false, desc: 'Use interactive wizard mode'
         def create(description = nil)
           handle_command_error('create agent') do
+            # Read from stdin if available and no description provided
+            description = $stdin.read.strip if description.nil? && !$stdin.tty?
+
             # Activate wizard mode if --wizard flag or no description provided
-            if options[:wizard] || description.nil?
+            if options[:wizard] || description.nil? || description.empty?
               description = Ux::CreateAgent.execute(ctx)
 
               # User cancelled wizard
@@ -328,6 +331,7 @@ module LanguageOperator
 
         desc 'code NAME', 'Display synthesized agent code'
         option :cluster, type: :string, desc: 'Override current cluster context'
+        option :raw, type: :boolean, default: false, desc: 'Output raw code without formatting'
         def code(name)
           handle_command_error('get code') do
             require_relative '../formatters/code_formatter'
@@ -357,15 +361,17 @@ module LanguageOperator
               exit 1
             end
 
+            # Raw output mode - just print the code
+            if options[:raw]
+              puts code_content
+              return
+            end
+
             # Display with syntax highlighting
             Formatters::CodeFormatter.display_ruby_code(
               code_content,
               title: "Synthesized Code for Agent: #{name}"
             )
-
-            puts
-            puts 'This code was automatically synthesized from the agent instructions.'
-            puts "View full agent details with: aictl agent inspect #{name}"
           end
         end
 
@@ -752,18 +758,13 @@ module LanguageOperator
         end
 
         def watch_synthesis_status(k8s, agent_name, namespace)
-          # Start with analyzing description
-          puts
-          Formatters::ProgressFormatter.info('Synthesizing agent code...')
-          puts
-
           max_wait = 600 # Wait up to 10 minutes (local models can be slow)
           interval = 2   # Check every 2 seconds
           elapsed = 0
           start_time = Time.now
           synthesis_data = {}
 
-          result = Formatters::ProgressFormatter.with_spinner('Analyzing description and generating code') do
+          result = Formatters::ProgressFormatter.with_spinner('Synthesizing code from instructions') do
             loop do
               status = check_synthesis_status(k8s, agent_name, namespace, synthesis_data, start_time)
               return status if status

data/lib/language_operator/cli/commands/tool.rb

@@ -158,7 +158,7 @@ module LanguageOperator
             end
 
             # Render template
-            template = ERB.new(template_content)
+            template = ERB.new(template_content, trim_mode: '-')
             yaml_content = template.result_with_hash(vars)
 
             # Dry run mode

data/lib/language_operator/cli/formatters/code_formatter.rb

@@ -32,25 +32,15 @@ module LanguageOperator
               code_to_display = code_content
             end
 
-            # Print header
-            puts
-            puts pastel.cyan(title) if title
-            puts pastel.dim('─' * 80)
-            puts
-
             # Highlight and print the code
             highlighted = formatter.format(lexer.lex(code_to_display))
             puts highlighted
 
             # Show truncation notice if applicable
-            if truncated
-              puts
-              puts pastel.dim("... #{remaining_lines} more lines ...")
-            end
+            return unless truncated
 
-            # Print footer
             puts
-            puts pastel.dim('─' * 80)
+            puts pastel.dim("... #{remaining_lines} more lines ...")
           end
 
           # Display a code snippet with context

data/lib/language_operator/config/tool_registry.rb

@@ -25,18 +25,11 @@ module LanguageOperator
         # Return cached data if still valid
         return @cache if @cache && @cache_time && (Time.now - @cache_time) < CACHE_TTL
 
-        # Fetch from remote
-        begin
-          tools = fetch_remote
-          @cache = tools
-          @cache_time = Time.now
-          tools
-        rescue StandardError => e
-          # Fall back to local file if remote fetch fails
-          warn "Failed to fetch remote registry: #{e.message}"
-          warn 'Falling back to local registry'
-          fetch_local
-        end
+        # Fetch from remote (no fallback)
+        tools = fetch_remote
+        @cache = tools
+        @cache_time = Time.now
+        tools
       end
 
       # Clear the cache to force a fresh fetch
@@ -83,14 +76,6 @@ module LanguageOperator
           response
         end
       end
-
-      def fetch_local
-        # Fall back to bundled local registry
-        patterns_path = File.join(__dir__, 'tool_patterns.yaml')
-        return {} unless File.exist?(patterns_path)
-
-        YAML.load_file(patterns_path)
-      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.55
+  :version: 0.1.56
   :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.55",
+  "version": "0.1.56",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/tool_loader.rb

@@ -69,14 +69,9 @@ module LanguageOperator
         context = LanguageOperator::Dsl::Context.new(@registry)
         code = File.read(file)
 
-        # Execute in sandbox with validation
-        executor = LanguageOperator::Agent::Safety::SafeExecutor.new(context)
-        executor.eval(code, file)
-      rescue Agent::Safety::SafeExecutor::SecurityError, Agent::Safety::ASTValidator::SecurityError => e
-        # Re-raise security errors so they're not silently ignored
-        warn "Error loading tool file #{file}: #{e.message}"
-        warn e.backtrace.join("\n")
-        raise e
+        # Tools are trusted code - execute directly without sandbox validation
+        # Only synthesized agent code should be sandboxed
+        context.instance_eval(code, file)
       rescue StandardError => e
         warn "Error loading tool file #{file}: #{e.message}"
         warn e.backtrace.join("\n")

data/lib/language_operator/ux/create_agent.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'base'
+require_relative 'concerns/headings'
 require_relative '../cli/helpers/schedule_builder'
 
 module LanguageOperator
@@ -14,6 +15,8 @@ module LanguageOperator
     #
     # rubocop:disable Metrics/ClassLength, Metrics/AbcSize
     class CreateAgent < Base
+      include Concerns::Headings
+
       # Execute the agent creation flow
       #
       # @return [String, nil] Generated description or nil if cancelled

data/lib/language_operator/version.rb

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

data/synth/001/Makefile

@@ -1,14 +1,16 @@
-.PHONY: synthesize exec
+.PHONY: create code logs clean
 
-help:
-	@echo "Synthesis Test Targets:"
-	@echo "  make synthesize         - Generate agent.rb using default model"
-	@echo "  make run                - Execute agent.rb locally with bundle exec"
-	@echo "  make validate           - Validate agent.rb syntax"
-	@echo "  make clean              - Remove all generated .rb files"
+AGENT := synth-001
+AICTL := bundle exec ../../bin/aictl agent
 
-synthesize:
-	cat agent.txt | bundle exec ../../bin/aictl system synthesize --raw | tee agent.rb
+create:
+	cat agent.txt | $(AICTL) create --name $(AGENT)
 
-exec:
-	cat agent.rb | bundle exec ../../bin/aictl system exec | tee output.log
+code:
+	$(AICTL) code $(AGENT)
+
+logs:
+	$(AICTL) logs $(AGENT)
+
+clean:
+	$(AICTL) delete $(AGENT) --force

data/synth/001/README.md

@@ -6,27 +6,27 @@
 
 ## Significance
 
-This is the **foundational validation** of the DSL v1 architecture. It proves that the entire synthesis pipeline works end-to-end with the simplest possible agent.
+This is a basic validation of the DSL v1 architecture. It checks that the synthesis pipeline works end-to-end with a simple agent.
 
-Think of this as the "Hello World" of organic function synthesis - before we can validate learning, progressive synthesis, or neural task execution, we must first prove we can synthesize and execute *anything at all*.
+This is essentially a "Hello World" test - before attempting more complex features like learning or neural task execution, we need to verify that we can synthesize and execute basic functionality.
 
 ## What This Demonstrates
 
 ### 1. Basic Synthesis Flow Works
-- **Natural language → Agent code generation** - The synthesis template can produce valid Ruby DSL
+- **Natural language → Agent code generation** - The synthesis template produces valid Ruby DSL
 - **Go operator synthesis** - The operator's synthesis controller generates executable code
-- **ConfigMap storage** - Synthesized code is stored and mounted correctly
+- **ConfigMap storage** - Synthesized code is stored and mounted
 
 ### 2. DSL v1 Core Primitives
 - **`task` definition** - Symbolic task with explicit implementation block
 - **`main` block** - Explicit entry point with imperative control flow
-- **`execute_task`** - Task invocation mechanism works
+- **`execute_task`** - Task invocation mechanism
 - **`output` block** - Result handling and processing
 
 ### 3. Ruby Runtime Execution
-- **DSL parsing** - Ruby gem can load and parse synthesized agents
-- **Task execution** - `TaskExecutor` can execute symbolic tasks
-- **Agent lifecycle** - Agent runs to completion successfully
+- **DSL parsing** - Ruby gem loads and parses synthesized agents
+- **Task execution** - `TaskExecutor` executes symbolic tasks
+- **Agent lifecycle** - Agent runs to completion
 
 ### 4. Symbolic Task Execution
 ```ruby
@@ -35,7 +35,7 @@ task :generate_log_message do |_inputs|
 end
 ```
 
-This is a **symbolic organic function** - explicit code implementation with a stable contract:
+This is a symbolic organic function - explicit code implementation with a defined contract:
 - **Contract**: `outputs: { message: 'string' }`
 - **Implementation**: Returns hard-coded message
 - **Caller**: `main` block calls via `execute_task(:generate_log_message)`
@@ -43,7 +43,7 @@ This is a **symbolic organic function** - explicit code implementation with a st
 ## Why This Matters
 
 ### Validates the Foundation
-Before building complex features (learning, neural execution, re-synthesis), we must prove the basic pipeline works:
+Before building more complex features (learning, neural execution, re-synthesis), we need to verify the basic pipeline works:
 
 ```
 User Instruction
@@ -58,15 +58,15 @@ Output
 ```
 
 ### Establishes DSL v1 Baseline
-This test uses the **new DSL v1 model** (task/main) rather than the old workflow/step model. It proves:
+This test uses the new DSL v1 model (task/main) rather than the old workflow/step model. It verifies:
 - ✅ `task` replaces `step`
 - ✅ `main` replaces implicit `workflow`
 - ✅ Imperative control flow works
-- ✅ Organic function abstraction is viable
+- ✅ Organic function abstraction works
 
 ### No Neural Complexity Yet
-By using a **purely symbolic task**, this test isolates synthesis validation from LLM execution complexity:
+By using a purely symbolic task, this test isolates synthesis validation from LLM execution complexity:
 - No LLM API calls to fail
 - No neural task instruction parsing
 - No MCP server connections
-- Just pure: synthesize → execute → output
+- Just: synthesize → execute → output

data/synth/001/agent.rb

@@ -2,16 +2,25 @@
 
 require 'language_operator'
 
-agent 'test-agent' do
-  description 'Log a message to stdout as per instructions'
+agent '001' do
+  description 'Continuously logs a message to stdout'
 
-  task :generate_log_message do |_inputs|
-    { message: 'Test agent is saying hello!' }
+  task :generate_message do |inputs|
+    { message: "Agent 001 active at iteration #{inputs[:iteration]}" }
   end
 
-  main do |_inputs|
-    result = execute_task(:generate_log_message)
-    result
+  main do |inputs|
+    current_iteration = inputs[:iteration] || 0
+    message_data = execute_task(:generate_message, inputs: { iteration: current_iteration })
+    {
+      iteration: current_iteration + 1,
+      message: message_data[:message]
+    }
+  end
+
+  constraints do
+    max_iterations 999_999
+    timeout '10m'
   end
 
   output do |outputs|

data/synth/002/Makefile

@@ -1,12 +1,16 @@
-.PHONY: synthesize exec help
+.PHONY: create code logs clean
 
-help:
-	@echo "Synthesis Test Targets:"
-	@echo "  make synthesize         - Generate agent.rb using default model"
-	@echo "  make exec                - Execute agent.rb locally with bundle exec"
+AGENT := synth-002
+AICTL := bundle exec ../../bin/aictl agent
 
-synthesize:
-	cat agent.txt | bundle exec ../../bin/aictl system synthesize --raw | tee agent.rb
+create:
+	cat agent.txt | $(AICTL) create --name $(AGENT)
 
-exec:
-	cat agent.rb | bundle exec ../../bin/aictl system exec | tee output.log
+code:
+	$(AICTL) code $(AGENT)
+
+logs:
+	$(AICTL) logs $(AGENT)
+
+clean:
+	$(AICTL) delete $(AGENT) --force

data/synth/002/README.md

@@ -6,11 +6,11 @@
 
 ## Significance
 
-This is the **core validation of the Organic Function concept** - the secret sauce that makes DSL v1 revolutionary.
+This validates the Organic Function concept in DSL v1.
 
-While test 001 proved we can synthesize and execute code at all, this test proves we can execute **neural organic functions** - tasks defined purely by instructions where the LLM decides implementation at runtime.
+While test 001 verified we can synthesize and execute code, this test verifies we can execute neural organic functions - tasks defined purely by instructions where the LLM decides implementation at runtime.
 
-This is what differentiates Language Operator from every other agent framework. No other system can do this.
+This demonstrates one of the key features that differentiates Language Operator from traditional agent frameworks.
 
 ## What This Demonstrates
 
@@ -22,13 +22,13 @@ task :generate_fortune,
   outputs: { fortune: 'string' }
 ```
 
-This is a **neural organic function** - the implementation exists only as natural language instructions:
+This is a neural organic function - the implementation exists only as natural language instructions:
 - ✅ **No explicit code block** - Task has no `do |inputs| ... end`
 - ✅ **LLM synthesizes behavior** - Runtime passes instructions to LLM at execution time
 - ✅ **Contract enforcement** - Output must match `{ fortune: 'string' }` schema
 - ✅ **Caller transparency** - `execute_task(:generate_fortune)` works identically to symbolic tasks
 
-**This is the organic function abstraction in action**: The caller doesn't know (and doesn't care) whether the task is neural or symbolic.
+This demonstrates the organic function abstraction: The caller doesn't know (and doesn't care) whether the task is neural or symbolic.
 
 ### 2. Scheduled Execution Mode
 ```ruby
@@ -100,9 +100,9 @@ The runtime must validate that the LLM's response matches the output schema:
 
 ## Why This Matters
 
-### The Organic Function Secret Sauce
+### The Organic Function Approach
 
-This test validates the **fundamental innovation** of DSL v1:
+This test validates a key feature of DSL v1:
 
 **Traditional Approach (LangChain, AutoGen, etc.):**
 ```python
@@ -135,21 +135,21 @@ end
 result = execute_task(:generate_fortune)
 ```
 
-**The Magic**: The contract (`outputs: { fortune: 'string' }`) is stable. The implementation (neural vs symbolic) can change without breaking callers.
+**The key insight**: The contract (`outputs: { fortune: 'string' }`) is stable. The implementation (neural vs symbolic) can change without breaking callers.
 
 ### Enables Progressive Synthesis
 
-This test proves the foundation for learning:
+This test validates the foundation for learning:
 
 1. **Run 1-10**: Neural execution (this test validates this works)
 2. **System observes**: LLM always calls the same tools, returns same pattern
 3. **Run 11+**: Symbolic execution (future re-synthesis test validates this)
 
-**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.
+Because `execute_task(:generate_fortune)` works the same whether the task is neural or symbolic, we can replace implementations without breaking the `main` block.
 
 ## The Organic Function In Action
 
-**What makes this revolutionary:**
+**What this approach enables:**
 
 1. **Instant Working Code**: User says "tell me a fortune" → Agent runs immediately (neural)
 2. **No Manual Implementation**: Never wrote `execute_llm()` or fortune generation logic
@@ -157,4 +157,4 @@ This test proves the foundation for learning:
 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.
+This demonstrates "living code": Code that starts neural (flexible, works immediately) and becomes symbolic (fast, cheap) through observation, all while maintaining a stable contract.

data/synth/003/Makefile

@@ -0,0 +1,21 @@
+.PHONY: create code logs clean
+
+AGENT := synth-003
+AICTL := bundle exec ../../bin/aictl agent
+TOOLS := workspace
+
+create:
+	cat agent.txt | $(AICTL) create --name $(AGENT) --tools "$(TOOLS)"
+
+code:
+	$(AICTL) code $(AGENT)
+
+logs:
+	$(AICTL) logs $(AGENT)
+
+clean:
+	$(AICTL) delete $(AGENT) --force
+
+save:
+	$(AICTL) code $(AGENT) --raw > agent.rb
+	$(AICTL) logs $(AGENT) > output.log

data/synth/003/README.md

@@ -0,0 +1,188 @@
+# 003 - Workspace File Operations & Scheduled Mode
+
+## Instructions
+
+"Write a story one sentence at a time, with one new sentence every hour."
+
+## Significance
+
+This test validates **stateful execution with workspace file operations** - the ability for agents to persist and accumulate data across multiple scheduled executions.
+
+While test 002 proved we can execute neural tasks on a schedule, this test proves we can maintain **persistent state** across runs using the workspace directory.
+
+## What This Demonstrates
+
+### 1. Workspace File Operations
+
+Agents have access to a persistent workspace directory for file operations:
+- ✅ **File reading** - Check if story file exists and read current content
+- ✅ **File writing** - Append new sentences to the story
+- ✅ **Stateful execution** - Each run builds on previous runs
+- ✅ **Standard Ruby File APIs** - Use `File.read`, `File.write`, etc.
+
+### 2. Scheduled Execution with State
+
+```ruby
+mode :scheduled
+schedule "0 * * * *"  # Every hour
+```
+
+Validates that scheduled agents can maintain state across runs:
+- ✅ **Persistent storage** - Workspace directory survives pod restarts
+- ✅ **Cumulative behavior** - Each execution reads previous state, adds to it
+- ✅ **Multi-run workflows** - Tasks that span multiple scheduled executions
+
+### 3. Complete Stateful Execution Flow
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Kubernetes CronJob Triggers (every hour)               │
+│  Pod starts with mounted workspace volume               │
+└────────────────────┬────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────┐
+│  Agent Runtime Loads                                    │
+│  Mode: scheduled → Execute once and exit                │
+└────────────────────┬────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────┐
+│  main Block Executes                                    │
+│  1. Check if story.txt exists in workspace              │
+│  2. Read existing content (if any)                      │
+│  3. Execute task to generate next sentence              │
+│  4. Append sentence to story.txt                        │
+└────────────────────┬────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────┐
+│  File persisted to workspace volume                     │
+│  Pod exits → Kubernetes waits for next hour             │
+└─────────────────────────────────────────────────────────┘
+                     │
+                     ▼
+┌─────────────────────────────────────────────────────────┐
+│  Next Hour: New pod starts                              │
+│  Same workspace volume mounted                          │
+│  Reads previous content, adds new sentence              │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Why This Matters
+
+### Stateful Agents Enable New Use Cases
+
+This test unlocks a critical capability for real-world agents:
+
+**Before (Stateless):**
+- Each execution is isolated
+- No memory of previous runs
+- Limited to one-shot tasks
+
+**After (Stateful with Workspace):**
+- Accumulate data over time
+- Build complex artifacts across multiple runs
+- Enable learning and evolution
+
+### Real-World Applications
+
+This pattern enables:
+
+1. **Incremental Report Building** - Add data to reports over days/weeks
+2. **Data Collection Pipelines** - Append to datasets on each run
+3. **Monitoring & Alerting** - Track state changes across time
+4. **Creative Projects** - Build stories, documents, code incrementally
+5. **Learning Systems** - Store observations and improve over time
+
+## Expected Behavior
+
+### Run 1 (Hour 1)
+- Story file doesn't exist
+- Agent generates opening sentence
+- Writes: "Once upon a time, there was a brave knight."
+
+### Run 2 (Hour 2)
+- Story file exists with 1 sentence
+- Agent reads it, generates next sentence
+- Appends: "The knight embarked on a quest to find the lost treasure."
+
+### Run 3 (Hour 3)
+- Story file exists with 2 sentences
+- Agent reads it, generates continuation
+- Appends: "Along the way, she met a wise old wizard."
+
+...and so on, building a complete story over time.
+
+## Technical Implementation Notes
+
+### Workspace Directory
+
+- **Location**: Typically `/workspace` in the container
+- **Persistence**: Backed by Kubernetes PersistentVolume
+- **Access**: Standard Ruby `File` and `Dir` operations
+- **Lifecycle**: Survives pod restarts, shared across scheduled runs
+
+### File Operation Patterns
+
+```ruby
+# Read existing story
+story_path = '/workspace/story.txt'
+existing_story = File.exist?(story_path) ? File.read(story_path) : ""
+
+# Generate next sentence (neural task)
+next_sentence = execute_task(:generate_next_sentence, inputs: { context: existing_story })
+
+# Append to story
+File.open(story_path, 'a') do |f|
+  f.puts next_sentence
+end
+```
+
+## Testing Locally
+
+```bash
+# Synthesize the agent
+make synthesize
+
+# Execute locally (simulates one run)
+make exec
+
+# Run multiple times to simulate scheduled execution
+make exec  # Run 1
+make exec  # Run 2
+make exec  # Run 3
+```
+
+Each local execution should append to the story, demonstrating the stateful behavior.
+
+## What Makes This Interesting
+
+### 1. Emergent Behavior
+The agent doesn't know the full story in advance - it emerges sentence by sentence, with each new sentence influenced by what came before.
+
+### 2. LLM Context Management
+The agent must pass the growing story as context to generate coherent continuations. This tests context window management.
+
+### 3. File I/O Integration
+Proves that agents can use standard Ruby file operations within the safety sandbox.
+
+### 4. Time-Based Workflows
+Demonstrates workflows that unfold over hours/days, not just seconds.
+
+## Success Criteria
+
+- ✅ Agent successfully reads workspace files
+- ✅ Agent successfully writes/appends to workspace files
+- ✅ Story grows by one sentence per execution
+- ✅ Each sentence is contextually coherent with previous sentences
+- ✅ File persists across multiple runs
+- ✅ No errors in scheduled execution
+
+## Future Extensions
+
+This pattern could be extended to:
+- **Multi-file projects** - Build entire codebases incrementally
+- **Data analysis** - Accumulate findings in structured files
+- **Version control integration** - Track changes over time
+- **Collaboration** - Multiple agents reading/writing shared files

data/synth/003/agent.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'language_operator'
+
+agent 'synth-003' do
+  description 'Build a story one sentence at a time, adding exactly one new sentence every hour'
+  mode :scheduled
+  schedule '0 * * * *'
+
+  task :read_existing_story,
+       instructions: "Read the story.txt file from workspace. If it doesn't exist, return empty string for content and 0 for sentence count. Return the content and number of sentences (count newlines as sentence separators).",
+       inputs: {},
+       outputs: { content: 'string', sentence_count: 'integer' }
+
+  task :generate_next_sentence,
+       instructions: 'Generate exactly one new sentence to continue this story. Maintain consistent tone and style from the existing content. Only output the new sentence without any additional text or formatting.',
+       inputs: { existing_content: 'string' },
+       outputs: { sentence: 'string' }
+
+  task :append_to_story,
+       instructions: 'Append the new sentence to story.txt in workspace. If the file has existing content, add a newline before appending. Return whether the operation succeeded and the new total sentence count (counting existing sentences plus one).',
+       inputs: { sentence: 'string' },
+       outputs: { success: 'boolean', total_sentences: 'integer' }
+
+  main do |_inputs|
+    story_data = execute_task(:read_existing_story)
+    new_sentence = execute_task(:generate_next_sentence, inputs: { existing_content: story_data[:content] })
+    result = execute_task(:append_to_story, inputs: { sentence: new_sentence[:sentence] })
+    { added_sentence: new_sentence[:sentence], total_sentences: result[:total_sentences] }
+  end
+
+  constraints do
+    max_iterations 999_999
+    timeout '10m'
+  end
+
+  output do |outputs|
+    puts "Added sentence: #{outputs[:added_sentence]}"
+    puts "Story now has #{outputs[:total_sentences]} sentences"
+  end
+end

data/synth/003/agent.txt

@@ -0,0 +1 @@
+Write a story one sentence at a time, with one new sentence every hour.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.55
+  version: 0.1.56
 platform: ruby
 authors:
 - James Ryan
@@ -557,6 +557,10 @@ files:
 - synth/002/agent.rb
 - synth/002/agent.txt
 - synth/002/output.log
+- synth/003/Makefile
+- synth/003/README.md
+- synth/003/agent.rb
+- synth/003/agent.txt
 - synth/README.md
 homepage: https://github.com/language-operator/language-operator
 licenses: