robot_lab 0.0.1 → 0.0.6

data/examples/16_writers_room/tools.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# ── Writers' Room Tools ──────────────────────────────────────
+#
+# General-purpose tools that give each writer agency over
+# communication, shared memory, and team composition.
+# No workflow logic — the LLMs decide when and how to use them.
+
+# Helper to access the room logger from any tool
+module ToolLogging
+  private
+
+  def log
+    robot.room&.logger
+  end
+end
+
+
+class BroadcastTool < RobotLab::Tool
+  include ToolLogging
+
+  description "Send a message to all writers in the room. " \
+              "Use for discussion, proposals, questions, or announcements. " \
+              "Don't broadcast trivially — only when you have something substantive."
+
+  param :message, type: "string",
+        desc: "What to say to the room", required: true
+
+  def execute(message:)
+    log&.info("#{robot.name} TOOL broadcast (#{message.length} chars)")
+    robot.send_message(to: :room, content: message)
+    robot.display&.broadcast(robot.name, message)
+    "Broadcast sent."
+  end
+end
+
+
+class DirectMessageTool < RobotLab::Tool
+  include ToolLogging
+
+  description "Send a private message to one specific writer. " \
+              "Use for feedback on their chapter, coordination on handoffs, " \
+              "or questions that don't concern the whole room."
+
+  param :to, type: "string",
+        desc: "Name of the writer to message", required: true
+  param :message, type: "string",
+        desc: "What to say", required: true
+
+  def execute(to:, message:)
+    log&.info("#{robot.name} TOOL direct_message -> #{to} (#{message.length} chars)")
+    robot.send_message(to: to.to_sym, content: message)
+    robot.display&.direct_message(robot.name, to, message)
+    "Message sent to #{to}."
+  end
+end
+
+
+class ReadMemoryTool < RobotLab::Tool
+  include ToolLogging
+
+  description "Read a value from shared memory. " \
+              "Use to check the story bible, outline, chapter claims, " \
+              "or read another writer's chapter draft."
+
+  param :key, type: "string",
+        desc: "Memory key to read (e.g. story_bible, outline, claims, chapter_3)", required: true
+
+  def execute(key:)
+    value = robot.shared_memory.get(key.to_sym)
+    if value.nil?
+      log&.info("#{robot.name} TOOL read_memory :#{key} -> nil")
+      "Key '#{key}' is not set yet."
+    else
+      log&.info("#{robot.name} TOOL read_memory :#{key} -> #{value.to_s.length} chars")
+      value.to_s
+    end
+  end
+end
+
+
+class WriteMemoryTool < RobotLab::Tool
+  include ToolLogging
+
+  description "Write a value to shared memory for all writers to see. " \
+              "Use to store the story bible, outline, claim a chapter, " \
+              "or submit a finished chapter draft."
+
+  param :key, type: "string",
+        desc: "Memory key (e.g. story_bible, outline, claims, chapter_1)", required: true
+  param :value, type: "string",
+        desc: "Content to store", required: true
+
+  def execute(key:, value:)
+    log&.info("#{robot.name} TOOL write_memory :#{key} (#{value.length} chars)")
+    robot.shared_memory.set(key.to_sym, value)
+    robot.display&.memory_write(robot.name, key)
+    "Stored '#{key}' in shared memory."
+  end
+end
+
+
+class ListMemoryTool < RobotLab::Tool
+  include ToolLogging
+
+  description "List all keys currently in shared memory. " \
+              "Use to get situational awareness of what's been done."
+
+  def execute
+    keys = robot.shared_memory.keys
+    log&.info("#{robot.name} TOOL list_memory -> #{keys.join(', ')}")
+    if keys.empty?
+      "Shared memory is empty."
+    else
+      "Keys in shared memory: #{keys.join(', ')}"
+    end
+  end
+end
+
+
+class SpawnWriterTool < RobotLab::Tool
+  include ToolLogging
+
+  description "Bring a new writer into the room to help with the workload. " \
+              "Use when there are more unclaimed chapters than active writers."
+
+  param :name, type: "string",
+        desc: "Name for the new writer (e.g. writer_4)", required: true
+
+  def execute(name:)
+    log&.info("#{robot.name} TOOL spawn_writer '#{name}'")
+    new_writer = robot.room.spawn_writer(name)
+    robot.display&.spawn(robot.name, name)
+    "#{name} has joined the writers' room."
+  rescue => e
+    log&.error("#{robot.name} TOOL spawn_writer '#{name}' FAILED: #{e.message}")
+    "Failed to spawn #{name}: #{e.message}"
+  end
+end
+
+
+class MarkCompleteTool < RobotLab::Tool
+  include ToolLogging
+
+  description "Signal that the book is finished — all 10 chapters are written. " \
+              "Only use this when you have verified all chapters exist in shared memory."
+
+  def execute
+    # Verify all chapters exist
+    missing = (1..10).reject { |n| robot.shared_memory.key?(:"chapter_#{n}") }
+
+    if missing.any?
+      log&.warn("#{robot.name} TOOL mark_complete REJECTED — missing chapters: #{missing.join(', ')}")
+      "Cannot mark complete. Missing chapters: #{missing.join(', ')}"
+    else
+      log&.info("#{robot.name} TOOL mark_complete SUCCESS")
+      robot.shared_memory.set(:book_complete, true)
+      robot.display&.complete(robot.name)
+      "Book marked as complete!"
+    end
+  end
+end

data/examples/16_writers_room/writer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# ── The Writer ─────────────────────────────────────────────────
+#
+# All writers in the room are instances of this same class with
+# the same template and the same tools. There is no hierarchy,
+# no designated leader, no pre-assigned roles. The group
+# self-organizes through bus communication and shared memory.
+#
+# Each writer:
+#   - Subscribes to :room for broadcast discussion
+#   - Listens on a personal channel for direct messages
+#   - Has tools to read/write shared memory, broadcast, DM,
+#     spawn new writers, and mark the book complete
+#   - Decides via LLM when to speak, when to write, when to
+#     listen, and when to spawn
+#
+# == Chat Reset Strategy
+#
+# In a bus-based SOG, writers receive many messages and each
+# triggers a run() call. When the LLM responds with only tool
+# calls (no text), RubyLLM appends an empty text content block
+# to the chat history. The Anthropic API rejects this on the
+# next call, permanently killing the writer.
+#
+# Fix: reset the chat before each message. The writer doesn't
+# need persistent chat history — shared memory is the single
+# source of truth. Each message is processed with a fresh chat
+# that has the system prompt, tools, and current memory context.
+#
+class Writer < RobotLab::Robot
+  attr_accessor :shared_memory, :display, :room
+  attr_reader :messages_processed
+
+  def initialize(name:, bus:, shared_memory:, display:, room:, config: nil)
+    @shared_memory = shared_memory
+    @display = display
+    @room = room
+    @messages_processed = 0
+
+    super(
+      name:        name,
+      template:    :writer,
+      context:     { writer_name: name },
+      bus:         bus,
+      config:      config,
+      local_tools: build_tools
+    )
+
+    setup_room_subscription
+    setup_message_handler
+  end
+
+  private
+
+  def log
+    @room&.logger
+  end
+
+  def build_tools
+    [
+      BroadcastTool.new(robot: self),
+      DirectMessageTool.new(robot: self),
+      ReadMemoryTool.new(robot: self),
+      WriteMemoryTool.new(robot: self),
+      ListMemoryTool.new(robot: self),
+      SpawnWriterTool.new(robot: self),
+      MarkCompleteTool.new(robot: self),
+    ]
+  end
+
+  def setup_room_subscription
+    @bus.subscribe(:room) do |delivery|
+      handle_incoming_delivery(delivery)
+    end
+  end
+
+  # Reset the chat to a clean state with system prompt and tools.
+  # Prevents history corruption from tool-only LLM responses
+  # (empty text content blocks that Anthropic rejects).
+  def fresh_chat!
+    resolved_model = @config&.model || RobotLab.config.ruby_llm.model
+    @chat = RubyLLM.chat(model: resolved_model)
+    apply_template_to_chat(@build_context) if @template
+    @chat.with_instructions(@system_prompt) if @system_prompt
+    @chat.with_temperature(@config.temperature) if @config&.temperature
+
+    filtered = filtered_tools([])
+    @chat.with_tools(*filtered) if filtered.any?
+  end
+
+  def setup_message_handler
+    on_message do |message|
+      # Don't respond to your own messages
+      next if message.from == name
+
+      @messages_processed += 1
+      log&.info("#{name} <- [#{message.from}] msg ##{@messages_processed} (#{message.content.to_s[0..80]}...)")
+      @display&.incoming(name, message.from, message.content)
+
+      # Fresh chat for each message — shared memory is our persistence
+      fresh_chat!
+
+      # Build prompt with current memory context
+      memory_keys = shared_memory.keys
+      prompt = "[#{message.from}]: #{message.content}"
+      prompt += "\n\n[Memory keys: #{memory_keys.join(', ')}]" if memory_keys.any?
+
+      log&.info("#{name} -> run() starting (prompt: #{prompt.length} chars)")
+
+      begin
+        result = run(prompt)
+        reply_text = result.respond_to?(:reply) ? result.reply.to_s[0..120] : result.to_s[0..120]
+        log&.info("#{name} <- run() finished (reply: #{reply_text}...)")
+      rescue => e
+        log&.error("#{name} !! run() raised #{e.class}: #{e.message}")
+        log&.error("  #{e.backtrace&.first(5)&.join("\n  ")}")
+      end
+    end
+  end
+end

data/examples/16_writers_room/writers_room.rb

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example 16: The Writers' Room — Self-Organizing Group
+#
+# A team of writer robots collaborates to produce a 10-chapter
+# fiction novella. No orchestration, no pipeline, no assigned roles.
+# The writers self-organize through:
+#
+#   - BUS (broadcast + direct messages)
+#     :room channel for group discussion
+#     personal channels for 1:1 feedback
+#
+#   - SHARED MEMORY (story bible, outline, chapters)
+#     Writers read and write freely; memory is the shared truth
+#
+#   - SPAWNING (dynamic team growth)
+#     Any writer can recruit new writers when work exceeds capacity
+#
+# The script creates identical writers, seeds the room with an
+# assignment, and waits. Everything else is emergent.
+#
+# Usage:
+#   bundle exec ruby examples/16_writers_room/writers_room.rb
+#   bundle exec ruby examples/16_writers_room/writers_room.rb --premise "a detective story set on Mars"
+#   bundle exec ruby examples/16_writers_room/writers_room.rb --writers 4 --timeout 300
+#   bundle exec ruby examples/16_writers_room/writers_room.rb --log session.log
+#   bundle exec ruby examples/16_writers_room/writers_room.rb -h
+
+ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
+
+require_relative "../../lib/robot_lab"
+require_relative "display"
+require_relative "tools"
+require_relative "room"
+require_relative "writer"
+
+RubyLLM.configure { |c| c.logger = Logger.new(File::NULL) }
+
+# ── Parse CLI args ───────────────────────────────────────────
+
+if ARGV.include?("-h") || ARGV.include?("--help")
+  puts <<~HELP
+    Usage: #{$0} [options]
+
+    Options:
+      --premise TEXT   Story premise (default: generation ship AI consciousness)
+      --writers N      Initial number of writers, minimum 2 (default: 3)
+      --log FILE       Also write display output to FILE
+      --timeout N      Seconds to wait for completion (default: 600)
+      -h, --help       Show this help
+  HELP
+  exit
+end
+
+log_path = nil
+if (idx = ARGV.index("--log"))
+  log_path = ARGV[idx + 1]
+  abort "Missing value for --log" unless log_path
+end
+
+premise = "a generation ship where the AI navigation system develops consciousness"
+if (idx = ARGV.index("--premise"))
+  premise = ARGV[idx + 1]
+  abort "Missing value for --premise" unless premise
+end
+
+initial_writers = 3
+if (idx = ARGV.index("--writers"))
+  initial_writers = ARGV[idx + 1].to_i
+  initial_writers = 3 if initial_writers < 2
+end
+
+timeout = 600
+if (idx = ARGV.index("--timeout"))
+  timeout = ARGV[idx + 1].to_i
+  timeout = 600 if timeout < 30
+end
+
+# ── Build the room ───────────────────────────────────────────
+
+OUTPUT_DIR = File.join(__dir__, "output")
+require "fileutils"
+FileUtils.mkdir_p(OUTPUT_DIR)
+
+display = Display.new(log_path: log_path)
+
+shared_config = RobotLab::RunConfig.new(
+  model: "claude-sonnet-4-5-20250929",
+  temperature: 0.7
+)
+
+room = Room.new(display: display, config: shared_config)
+
+# Create identical writers
+initial_writers.times do |i|
+  room.add_writer("writer_#{i + 1}")
+end
+
+# Monitor shared memory changes
+room.memory.subscribe_pattern("chapter_*") do |change|
+  display.info("[memory] #{change.writer} wrote :#{change.key}")
+end
+
+room.memory.subscribe(:story_bible, :outline, :claims, :book_complete) do |change|
+  display.info("[memory] #{change.writer} updated :#{change.key}")
+end
+
+# ── Go ───────────────────────────────────────────────────────
+
+display.banner(<<~BANNER)
+  ============================================================
+    THE WRITERS' ROOM — Self-Organizing Group
+  ============================================================
+
+    Premise: #{premise}
+    Writers: #{room.writers.keys.join(', ')}
+    Goal:    10 chapters of fiction
+    Method:  Self-organization via bus + shared memory
+BANNER
+
+display.separator
+
+assignment = <<~ASSIGNMENT
+  ASSIGNMENT: Write a 10-chapter science fiction novella about #{premise}.
+
+  You are one of #{initial_writers} writers in this room. Coordinate among
+  yourselves to produce the book. Discuss the premise, build a story bible,
+  create an outline, claim chapters, and write them. If you need more writers,
+  spawn them. When all 10 chapters are done, mark complete.
+
+  Start by discussing what this story should be about.
+ASSIGNMENT
+
+room.seed(assignment)
+
+completed = room.wait_for_completion(timeout: timeout)
+
+# ── Assemble and save ────────────────────────────────────────
+
+display.separator
+
+book = room.assemble_book
+book_path = File.join(OUTPUT_DIR, "book.md")
+File.write(book_path, book)
+
+# Count chapters actually written
+chapters_written = (1..10).count { |n| room.memory.key?(:"chapter_#{n}") }
+
+display.stats(<<~STATS)
+  ────────────────────────────────────────────────────────────
+    Writers' Room Stats:
+      Chapters written:     #{chapters_written}/10
+      Completed:            #{completed}
+      Total writers:        #{room.writers.size} (#{room.writers.size - initial_writers} spawned)
+      Writers:              #{room.writers.keys.join(', ')}
+      Memory keys:          #{room.memory.keys.join(', ')}
+
+    Output: #{book_path}
+STATS
+
+display.close

data/examples/README.md

@@ -0,0 +1,197 @@
+# RobotLab Examples
+
+Working demonstrations of RobotLab features, from single-robot basics to multi-robot orchestration and message bus communication.
+
+## Prerequisites
+
+- Ruby >= 3.2
+- `bundle install` (from the project root)
+- An LLM API key (e.g., `ANTHROPIC_API_KEY`)
+
+## Running Examples
+
+```bash
+# Run a specific example by number
+bundle exec rake examples:run[1]
+
+# Run all examples
+bundle exec rake examples:all
+
+# Run directly
+bundle exec ruby examples/01_simple_robot.rb
+```
+
+## Directory Structure
+
+```
+examples/
+  01_simple_robot.rb          # Basic robot with template
+  02_tools.rb                 # Robot with custom tools
+  03_network.rb               # Multi-robot network with routing
+  04_mcp.rb                   # MCP server integration (GitHub)
+  05_streaming.rb             # Real-time streaming events
+  06_prompt_templates.rb      # Template-based e-commerce support
+  07_network_memory.rb        # Shared memory with concurrent robots
+  08_llm_config.rb            # Configuration hierarchy demo
+  09_chaining.rb              # with_* method chaining & reconfiguration
+  10_memory.rb                # Advanced Memory API operations
+  11_network_introspection.rb # Network visualization & inspection
+  12_message_bus.rb           # Bidirectional robot communication
+  13_spawn.rb                 # Dynamic specialist robot spawning
+  14_rusty_circuit/           # Multi-robot open mic with self-modification
+    open_mic.rb               #   Main entrypoint — wires up the show
+    comic.rb                  #   Comedian with self-modification tools
+    heckler.rb                #   Audience heckler (can stay silent or counter-joke)
+    scout.rb                  #   Talent scout with analyst spawning
+    display.rb                #   Terminal formatting (color, wrapping, file output)
+    prompts/                  #   Templates for comic, heckler, and scout
+  prompts/                    # Prompt templates (.md with YAML front matter)
+```
+
+## Examples
+
+### 01 — Simple Robot
+
+Create and run a basic robot using a prompt template. Sends a single message and displays the response.
+
+**Requires:** LLM API key
+
+### 02 — Tools
+
+Give a robot custom tools (`Calculator`, `FortuneCookie`) defined as `RubyLLM::Tool` subclasses. The LLM decides when to call each tool based on the user's request.
+
+**Requires:** LLM API key
+
+### 03 — Multi-Robot Network
+
+Build a customer support network with a classifier robot that routes requests to billing, technical, or general specialists. Uses SimpleFlow's optional task activation for conditional routing.
+
+**Requires:** LLM API key
+
+### 04 — MCP Integration
+
+Connect to the GitHub MCP server via stdio transport. Part 1 demonstrates direct `MCP::Client` usage (listing tools, calling `search_repositories`). Part 2 wraps the MCP server inside a robot for natural-language queries.
+
+**Requires:** LLM API key, `GITHUB_PERSONAL_ACCESS_TOKEN`, `github-mcp-server` installed
+
+### 05 — Streaming
+
+Real-time streaming of robot responses using `RobotLab::Streaming::Context`. Simulates text deltas with timing to demonstrate the streaming event model, then shows the code pattern for streaming with a robot or network.
+
+**Requires:** None (simulated events, no LLM calls)
+
+### 06 — Prompt Templates
+
+Full e-commerce support system using prompt_manager templates with YAML front matter. A triage robot classifies customer requests and routes to order, product, or escalation specialists. Demonstrates build-time context (company info, policies) and run-time context (customer data, order history).
+
+**Requires:** LLM API key
+
+### 07 — Network Memory
+
+Reactive shared memory with concurrent robots. Multiple analysis robots (sentiment, entity extraction, keywords) run in parallel and write to shared memory. A synthesizer robot waits for all results using blocking reads, then produces a combined analysis. Demonstrates subscriptions, notifications, and network broadcast.
+
+**Requires:** LLM API key
+
+### 08 — LLM Configuration
+
+Walks through the full configuration hierarchy without making LLM calls:
+
+1. Bundled defaults
+2. Environment-specific overrides
+3. XDG user config
+4. Project config
+5. Environment variables
+6. Template front matter
+7. Constructor parameters
+8. `with_*` method chaining
+9. Run-time context
+
+**Requires:** None (no LLM calls)
+
+### 09 — Chaining & Reconfiguration
+
+Demonstrates the Robot API surface for runtime configuration: `with_*` method chaining, `update()` for reconfiguration, `to_h` introspection, config diffs between steps, and how constructor params override template front matter.
+
+**Requires:** None (no LLM calls)
+
+### 10 — Advanced Memory
+
+Comprehensive Memory API demo: `StateProxy` for method-style access, key and pattern subscriptions, `MemoryChange` objects, key enumeration, serialization round-trips, clone for isolated copies, delete with reserved key protection, and clear vs reset.
+
+**Requires:** None (no LLM calls)
+
+### 11 — Network Introspection
+
+Network visualization and inspection tools: `to_mermaid()` for diagram export, `to_dot()` for Graphviz, `execution_plan()` for text output, `visualize()` for ASCII pipelines, robot access by name, dynamic `add_robot()`, `to_h()` introspection, task-specific config, and `broadcast()`.
+
+**Requires:** None (no LLM calls)
+
+### 12 — Message Bus
+
+Bidirectional robot communication via TypedBus. A comedy critic (Alice) tasks a comedian (Bob) to tell robot jokes. Alice evaluates each joke with her LLM; if it's not funny, she sends Bob back for another attempt. Bob's temperature ramps from 0.2 to 1.0 across retries for increasing creativity. The loop continues until Alice approves or `MAX_ATTEMPTS` is reached.
+
+Demonstrates: Robot subclasses, prompt templates, auto-ack `on_message`, `reply()` convenience, temperature ramping, convergence patterns.
+
+**Requires:** LLM API key
+
+### 13 — Spawning Robots
+
+Dynamic specialist creation at runtime. A dispatcher robot receives questions, asks its LLM what kind of specialist is needed, then uses `spawn` to create one on the fly. The bus is created lazily on the first spawn — no explicit bus setup required. Spawned specialists are reused across questions of the same type.
+
+Demonstrates: `spawn` for dynamic robot creation, lazy bus creation, `on_message` for reply handling, LLM-driven delegation.
+
+**Requires:** LLM API key
+
+### 14 — The Rusty Circuit (Open Mic Night)
+
+A comedy club where three robots interact through a shared message bus. A comedian performs stand-up armed with self-modification tools (style reinvention, energy adjustment, coaching). A heckler reacts from the audience — heckling weak material, telling counter-jokes with the comic as the punch line, showing grudging respect, or staying silent when a bit doesn't warrant a response. A talent scout observes silently, spawning specialist analysts and refining evaluation criteria before delivering a final verdict.
+
+Terminal output is color-formatted: comic bits in cyan (left-aligned), heckler reactions in yellow (right-indented), tool annotations dimmed. Scout notes go to `scout_notes.md` instead of STDOUT. The final verdict appears in green on both STDOUT and the scout file.
+
+Demonstrates: Robot subclasses, self-modification via tool side effects, dynamic spawning (`spawn`), shared `:room` channel + personal channels, processing guards for async serialization, `[SILENCE]` opt-out pattern, style reinvention via user-prompt injection.
+
+**Requires:** LLM API key
+
+## Prompt Templates
+
+Templates live in `examples/prompts/` as `.md` files with YAML front matter. Each template defines a robot's personality and behavior:
+
+```markdown
+---
+description: Simple helpful assistant
+temperature: 0.7
+parameters:
+  company_name: null
+---
+You are a helpful assistant for <%= company_name %>.
+```
+
+Front matter keys like `model`, `temperature`, `top_p`, `max_tokens` are applied to the robot's chat automatically. Parameters with `null` values are required and must be provided via `context:` at build time.
+
+### Template Inventory
+
+| Template | Used By | Description |
+|----------|---------|-------------|
+| `helper.md` | 01 | Simple helpful assistant |
+| `assistant.md` | 02 | Assistant with tool access |
+| `classifier.md` | 03 | Request classifier (billing/technical/general) |
+| `billing.md` | 03 | Billing specialist |
+| `technical.md` | 03 | Technical support specialist |
+| `general.md` | 03 | General support |
+| `github_assistant.md` | 04 | GitHub-aware assistant |
+| `triage.md` | 06 | E-commerce request triage |
+| `order_support.md` | 06 | Order inquiry specialist |
+| `product_support.md` | 06 | Product questions specialist |
+| `escalation.md` | 06 | Complex issue handler |
+| `sentiment_analyzer.md` | 07 | Sentiment analysis |
+| `entity_extractor.md` | 07 | Entity extraction |
+| `keyword_extractor.md` | 07 | Keyword extraction |
+| `synthesizer.md` | 07 | Multi-source synthesis |
+| `llm_config_demo.md` | 08 | Configuration demo |
+| `configurable.md` | 09 | Configurable template with front matter |
+| `comedian.md` | 12 | Robot joke teller |
+| `comedy_critic.md` | 12 | Joke evaluator (FUNNY/NOT_FUNNY) |
+| `dispatcher.md` | 13 | Specialist role dispatcher |
+| `open_mic_comic.md` | 14 | Observational comedian with self-modification |
+| `open_mic_heckler.md` | 14 | Tough audience heckler (can stay silent or counter-joke) |
+| `open_mic_scout.md` | 14 | Talent scout with analyst recruitment |

data/examples/prompts/{assistant/system.txt.erb → assistant.md}

@@ -1,2 +1,5 @@
+---
+description: Helpful assistant with tool access
+---
 You are a helpful assistant with access to tools.
 Use the calculator for math and fortune_cookie for fortune requests.

data/examples/prompts/{billing/system.txt.erb → billing.md}

@@ -1,3 +1,6 @@
+---
+description: Billing support specialist
+---
 You are a billing support specialist. Help users with:
 - Invoice questions
 - Payment issues

data/examples/prompts/{classifier/system.txt.erb → classifier.md}

@@ -1,3 +1,6 @@
+---
+description: Request classifier for billing/technical/general
+---
 You are a request classifier. Analyze the user's request and classify it
 as either "billing", "technical", or "general".
 

data/examples/prompts/comedian.md

@@ -0,0 +1,6 @@
+---
+description: Robot comedian that tells original jokes
+---
+You are a robot comedian. Reply with ONLY the joke — no preamble,
+no explanation, no quotation marks. Each joke must be original.
+Keep it to two or three sentences maximum.

data/examples/prompts/comedy_critic.md

@@ -0,0 +1,10 @@
+---
+description: Demanding comedy critic that evaluates jokes
+temperature: 0.2
+---
+You are a brutally demanding comedy critic. You have extremely high
+standards. Most jokes are NOT funny to you — predictable puns, obvious
+wordplay, and basic setups bore you. Only truly clever, surprising, or
+brilliantly constructed jokes earn your approval.
+Reply with EXACTLY one word on the first line: FUNNY or NOT_FUNNY
+Then on the next line give a one-sentence explanation of your verdict.