robot_lab-to 0.2.7 → 0.3.0

data/examples/01_basic_usage/basic_usage.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 #
 # Basic Usage would generally be as a CLI tool; however, its a library
-# so that means you can build it inot an application program.
+# so that means you can build it into an application program.
 #
 # ===========================================================================
 # 01_basic_usage — drive robot_lab-to programmatically
@@ -32,8 +32,8 @@
 # ---------------------------------------------------------------------------
 # Run it
 # ---------------------------------------------------------------------------
-#   # Local Ollama (default — no API key needed; requires `ollama serve`):
-#   ollama pull gpt-oss:20b
+#   # Local LM Studio (default — no API key needed; common.rb starts the server
+#   # and loads the model for you if they aren't already running/loaded):
 #   bundle exec ruby examples/01_basic_usage/basic_usage.rb
 #
 #   # A cloud model instead:
@@ -41,17 +41,15 @@
 #     ANTHROPIC_API_KEY=sk-... \
 #     bundle exec ruby examples/01_basic_usage/basic_usage.rb
 #
-# Configuration (all optional, via environment):
-#   RLTO_LOCAL     true|false   use a local Ollama model (default true)
-#   RLTO_PROVIDER  name         LLM provider (default: openai for local)
-#   RLTO_MODEL     id           model id (default: gpt-oss:20b for local)
-#   OLLAMA_BASE    url          Ollama OpenAI endpoint (default localhost:11434/v1)
+# Configuration (all optional, via environment; examples/.envrc sets these for you):
+#   RLTO_LOCAL     true|false   use a local LM Studio model (default true)
+#   RLTO_PROVIDER  name         LLM provider label (default: lms for local)
+#   RLTO_MODEL     id           model id (default: qwen/qwen3.8-27b for local)
+#   LMS_BASE_URL   url          LM Studio OpenAI-compatible endpoint (default localhost:1234/v1)
 # ===========================================================================
 
 require "fileutils"
-require "logger"
 require "open3"
-require "net/http"
 
 # Make the example runnable straight from the repo during development, with or
 # without `bundle exec`. (When the gem is installed normally, these paths simply
@@ -61,52 +59,22 @@ require "net/http"
   File.expand_path("../../../robot_lab/lib", __dir__) # sibling robot_lab/lib
 ].each { |p| $LOAD_PATH.unshift(p) if Dir.exist?(p) }
 
-require "ruby_llm"
 require "robot_lab"
 require "robot_lab/to"
+require_relative "../common"
 
 # --- configuration ---------------------------------------------------------
 
 LOCAL    = ENV.fetch("RLTO_LOCAL", "true") == "true"
-PROVIDER = ENV.fetch("RLTO_PROVIDER", LOCAL ? "openai" : "anthropic").to_sym
-MODEL    = ENV.fetch("RLTO_MODEL", LOCAL ? "qwen3.6:latest" : "claude-sonnet-4-6")
-OLLAMA   = ENV.fetch("OLLAMA_BASE", "http://localhost:11434/v1")
-
-# For a local model we route RubyLLM's :openai provider at Ollama's
-# OpenAI-compatible endpoint, refresh the registry so tool attachment works, and
-# run non-streaming (Ollama suppresses tool calls when streaming). See the
-# "Local Models" guide in the docs for why.
-def configure_local!
-  RubyLLM.configure do |c|
-    c.openai_api_base = OLLAMA
-    c.openai_api_key  = "ollama" # ignored by Ollama, but RubyLLM wants a value
-    c.request_timeout = 600
-  end
-  RubyLLM.logger.level = Logger::ERROR
-  RubyLLM.models.refresh!
-rescue StandardError => e
-  warn "warning: could not refresh Ollama models (#{e.class}: #{e.message})"
-end
+PROVIDER = ENV.fetch("RLTO_PROVIDER", LOCAL ? "lms" : "anthropic").to_sym
+MODEL    = ENV.fetch("RLTO_MODEL", LOCAL ? "qwen/qwen3.8-27b" : "claude-sonnet-4-6")
 
-# Fail fast with a friendly message if a local run can't reach Ollama.
-def preflight_local!
-  uri = URI.join(OLLAMA, "models")
-  Net::HTTP.start(uri.host, uri.port, open_timeout: 2, read_timeout: 2) do |http|
-    http.get(uri.request_uri)
-  end
-rescue StandardError
-  abort <<~MSG
-    Cannot reach an Ollama server at #{OLLAMA}.
-    Start it and pull a tool-capable model first:
-
-      ollama serve &
-      ollama pull #{MODEL}
-
-    Or run against a cloud model:
-      RLTO_LOCAL=false RLTO_PROVIDER=anthropic RLTO_MODEL=claude-sonnet-4-6 \\
-        ANTHROPIC_API_KEY=sk-... ruby #{File.basename(__FILE__)}
-  MSG
-end
+# ruby_llm has no native "lms" adapter. "lms" is this example's friendly label for
+# "a local LM Studio model"; setup (common.rb) resolves it to the :lms provider
+# adapter pointed at LM Studio, starting the server and loading MODEL as needed.
+# Everything passed to RobotLab uses the resolved provider; PROVIDER itself is
+# kept only for display.
+LLM_PROVIDER = setup(provider: PROVIDER, model: MODEL)
 
 # --- sandbox repository ----------------------------------------------------
 
@@ -352,15 +320,10 @@ OBJECTIVE = <<~OBJ.strip
   file. Call submit_result when the suite passes.
 OBJ
 
-if LOCAL
-  preflight_local!
-  configure_local!
-end
-
 clean_slate! # delete any project / .robot_lab_to left by a previous run
 sandbox = make_sandbox
 puts "Project dir:     #{sandbox}"
-puts "Provider/model:  #{PROVIDER}/#{MODEL} (#{LOCAL ? 'local Ollama' : 'cloud'})"
+puts "Provider/model:  #{PROVIDER}/#{MODEL} (#{LOCAL ? 'local LM Studio' : 'cloud'})"
 puts "Objective:       implement lib/roman_numeral.rb to pass the test suite"
 puts
 
@@ -370,10 +333,10 @@ RobotLab.on(FeedbackHook)
 Dir.chdir(sandbox) do
   RobotLab::To.run(
     OBJECTIVE,
-    provider:       PROVIDER,
+    provider:       LLM_PROVIDER,
     model:          MODEL,
     local_guards:   LOCAL,    # built-in file tools + small-model guardrails
-    stream:         !LOCAL,   # local Ollama tool calls require non-streaming
+    stream:         !LOCAL,   # local LM Studio tool calls run non-streaming
     max_iterations: 6,        # a richer task needs room to iterate
     run_dir:        RUN_DIR,  # keep logs + notes under this example directory
     # The change only commits if the seeded test suite passes:

data/examples/02_advanced_usage/README.md

@@ -11,7 +11,7 @@ autonomously implements the plan behind a real **quality gate**.
 │  (AskUser tool)   │   │  acceptance      │ spec │  passes AND the quality gate  │
 │                   │   │  test suite      │      │  is clean                     │
 └───────────────────┘   └──────────────────┘      └───────────────────────────────┘
-        gpt-5.5 (cloud)  ·  robot_lab Network          qwen3.6:latest (local Ollama)
+        gpt-5.5 (cloud)  ·  robot_lab Network          qwen/qwen3.8-27b (local LM Studio)
 ```
 
 This is the natural progression from
@@ -25,11 +25,11 @@ the implementer) writes the spec, so the implementer still can't game it.
 |-------|-------------------|-------|
 | 1 — Ideate | `AskUser` tool, network task, templated robot | OpenAI `gpt-5.5` |
 | 2 — Plan | sequential network `task … depends_on`, data hand-off, file tools | OpenAI `gpt-5.5` |
-| 3 — Implement | `RobotLab::To.run` autonomous loop, verify gate, `stop_when`, guardrails | local Ollama `qwen3.6:latest` |
+| 3 — Implement | `RobotLab::To.run` autonomous loop, verify gate, `stop_when`, guardrails | local LM Studio `qwen/qwen3.8-27b` |
 
 The reasoning phases run on a capable cloud model; the implementation loop runs
 fully local. Because both use RubyLLM's `:openai` provider but different endpoints
-(`api.openai.com` vs Ollama's `/v1`), and `openai_api_base` is global, the example
+(`api.openai.com` vs LM Studio's `/v1`), and `openai_api_base` is global, the example
 toggles it between the sequential phases.
 
 ## The quality gate
@@ -55,10 +55,12 @@ flog + flay) into an autonomous gate. Tune the thresholds with `FLOG_MAX` /
 
 ```bash
 export OPENAI_API_KEY="sk-..."     # ideation + planning (gpt-5.5)
-ollama serve &                     # implementation (local)
-ollama pull qwen3.6:latest
 ```
 
+`common.rb` starts the LM Studio server and loads the build model itself if
+they aren't already running/loaded, so there's nothing to start by hand for
+the implementation phase.
+
 ## Run it
 
 ```bash
@@ -75,8 +77,9 @@ acceptance suite and the local model implement it.
 |----------|---------|-------------|
 | `RLTO_REASON_MODEL` | `gpt-5.5` | model for ideate + plan |
 | `RLTO_REASON_PROVIDER` | `openai` | provider for ideate + plan |
-| `RLTO_BUILD_MODEL` | `qwen3.6:latest` | model for implementation |
-| `OLLAMA_BASE` | `http://localhost:11434/v1` | Ollama OpenAI-compatible endpoint |
+| `RLTO_BUILD_PROVIDER` | `lms` (falls back to `RLTO_PROVIDER`) | provider label for implementation; `lms` resolves to `:openai` routed at `LMS_BASE_URL` |
+| `RLTO_BUILD_MODEL` | `qwen/qwen3.8-27b` (falls back to `RLTO_MODEL`) | model for implementation |
+| `LMS_BASE_URL` | `http://localhost:1234/v1` | LM Studio OpenAI-compatible endpoint |
 | `FLOG_MAX` | `25` | per-method complexity ceiling |
 | `FLAY_MAX` | `40` | duplication-mass ceiling |
 

data/examples/02_advanced_usage/advanced_usage.rb

@@ -18,28 +18,29 @@
 #       suite* into the project (test/). It does not implement anything. Its
 #       reply is a one-paragraph implementation objective.
 #
-#   Phase 3  IMPLEMENT (robot_lab-to, local Ollama qwen3.6:latest)
+#   Phase 3  IMPLEMENT (robot_lab-to, local LM Studio qwen/qwen3.8-27b)
 #       robot_lab-to runs an autonomous loop that writes lib/ code until the
 #       Planner's acceptance suite passes AND a quality gate is clean. The
 #       verify command (quality_gate.rb) runs tests + rubocop + flog + flay, so
 #       the robot must earn each commit on correctness AND quality.
 #
 # Models (per your request): reasoning on OpenAI gpt-5.5, building on local
-# Ollama qwen3.6. Because both use RubyLLM's :openai provider but different
-# endpoints (api.openai.com vs Ollama's /v1), and openai_api_base is global, we
-# toggle it between the (sequential) phases.
+# LM Studio qwen/qwen3.8-27b. Because the phases use different providers and different
+# endpoints (api.openai.com vs LM Studio's /v1), and openai_api_base is global,
+# we toggle it between the (sequential) phases.
 #
 # Everything stays under examples/02_advanced_usage/ (project/, .robot_lab_to/),
 # both git-ignored and recreated on each run.
 #
-# Run it (from the gem root, with OPENAI_API_KEY set and Ollama serving qwen3.6):
+# Run it (from the gem root, with OPENAI_API_KEY set; common.rb starts the LM
+# Studio server and loads the build model for you if they aren't already
+# running/loaded):
 #   bundle exec ruby examples/02_advanced_usage/advanced_usage.rb
 # ===========================================================================
 
 require "fileutils"
 require "logger"
 require "open3"
-require "net/http"
 
 # Make the example runnable straight from the repo, with or without bundler.
 [
@@ -47,17 +48,19 @@ require "net/http"
   File.expand_path("../../../robot_lab/lib", __dir__) # sibling robot_lab/lib
 ].each { |p| $LOAD_PATH.unshift(p) if Dir.exist?(p) }
 
-require "ruby_llm"
 require "robot_lab"
 require "robot_lab/to"
+require_relative "../common"
 
 # --- configuration ---------------------------------------------------------
 
 REASON_PROVIDER = ENV.fetch("RLTO_REASON_PROVIDER", "openai").to_sym
-REASON_MODEL    = ENV.fetch("RLTO_REASON_MODEL", "gpt-5.5")        # real OpenAI
-BUILD_PROVIDER  = ENV.fetch("RLTO_BUILD_PROVIDER", "openai").to_sym
-BUILD_MODEL     = ENV.fetch("RLTO_BUILD_MODEL", "qwen3.6:latest")  # local Ollama
-OLLAMA_BASE     = ENV.fetch("OLLAMA_BASE", "http://localhost:11434/v1")
+REASON_MODEL    = ENV.fetch("RLTO_REASON_MODEL", "gpt-5.5")     # real OpenAI
+# Falls back to the shared RLTO_PROVIDER / RLTO_MODEL (examples/.envrc sets these)
+# so the build phase picks up the same local model as the other examples unless
+# RLTO_BUILD_PROVIDER / RLTO_BUILD_MODEL override it specifically.
+BUILD_PROVIDER  = ENV.fetch("RLTO_BUILD_PROVIDER", ENV.fetch("RLTO_PROVIDER", "lms")).to_sym
+BUILD_MODEL     = ENV.fetch("RLTO_BUILD_MODEL", ENV.fetch("RLTO_MODEL", "qwen/qwen3.8-27b")) # local LM Studio
 
 SANDBOX_DIR = File.expand_path("project", __dir__)
 RUN_DIR     = File.expand_path(".robot_lab_to", __dir__)
@@ -95,28 +98,17 @@ def use_real_openai!
   RubyLLM.logger.level = Logger::ERROR # keep raw API traffic out of the feed
 end
 
-# Implementation phase routes the :openai provider at the local Ollama endpoint.
-def use_ollama!
-  RubyLLM.configure do |c|
-    c.openai_api_base = OLLAMA_BASE
-    c.openai_api_key  = "ollama" # ignored by Ollama
-    c.request_timeout = 600
-  end
-  RubyLLM.logger.level = Logger::ERROR
-  RubyLLM.models.refresh! # register local models so tool attachment works
-rescue StandardError => e
-  warn "warning: could not refresh Ollama models (#{e.class}: #{e.message})"
+# Implementation phase uses the :lms provider against the local LM Studio endpoint
+# (or whatever BUILD_PROVIDER resolves to). common.rb's setup starts the LM Studio
+# server and loads BUILD_MODEL as needed; the "lms" label resolves to the :lms provider.
+def use_build_provider!
+  setup(provider: BUILD_PROVIDER, model: BUILD_MODEL)
 end
 
 # --- preflight -------------------------------------------------------------
 
 def preflight!
   abort "Set OPENAI_API_KEY (the ideation/planning phases use #{REASON_MODEL})." unless ENV["OPENAI_API_KEY"]
-
-  uri = URI.join(OLLAMA_BASE, "models")
-  Net::HTTP.start(uri.host, uri.port, open_timeout: 2, read_timeout: 2) { |h| h.get(uri.request_uri) }
-rescue StandardError
-  abort "Cannot reach Ollama at #{OLLAMA_BASE}. Start it and `ollama pull #{BUILD_MODEL}`."
 end
 
 # --- sandbox ---------------------------------------------------------------
@@ -243,7 +235,7 @@ RobotLab::Narrator.enable! # live narration for every robot, across all phases
 
 puts "Project dir:  #{sandbox}"
 puts "Reasoning:    #{REASON_PROVIDER}/#{REASON_MODEL} (cloud)   →  ideate + plan"
-puts "Building:     #{BUILD_PROVIDER}/#{BUILD_MODEL} (local Ollama)  →  implement"
+puts "Building:     #{BUILD_PROVIDER}/#{BUILD_MODEL} (local LM Studio)  →  implement"
 puts
 
 # -- Phases 1 & 2: ideate -> plan, as a robot_lab network --------------------
@@ -289,15 +281,15 @@ puts "Objective derived from the spec.\n\n"
 
 # -- Phase 3: autonomous implementation with robot_lab-to --------------------
 puts "── Phase 3: implementation (robot_lab-to, quality-gated) ──"
-use_ollama!
+build_llm_provider = use_build_provider!
 
 Dir.chdir(sandbox) do
   RobotLab::To.run(
     objective,
-    provider:       BUILD_PROVIDER,
+    provider:       build_llm_provider,
     model:          BUILD_MODEL,
     local_guards:   true,   # built-in file tools + small-model guardrails
-    stream:         false,  # Ollama tool calls require non-streaming
+    stream:         false,  # local LM Studio tool calls run non-streaming
     max_iterations: 8,
     run_dir:        RUN_DIR,
     verify_command: "ruby quality_gate.rb", # tests + rubocop + flog + flay

data/examples/03_scored/scored_run.rb

@@ -26,8 +26,8 @@
 # ---------------------------------------------------------------------------
 # Run it
 # ---------------------------------------------------------------------------
-#   # Local Ollama (default — no API key; requires `ollama serve`):
-#   ollama pull gpt-oss:20b
+#   # Local LM Studio (default — no API key; common.rb starts the server and
+#   # loads the model for you if they aren't already running/loaded):
 #   bundle exec ruby examples/03_scored/scored_run.rb
 #
 #   # A cloud model instead:
@@ -35,17 +35,15 @@
 #     ANTHROPIC_API_KEY=sk-... \
 #     bundle exec ruby examples/03_scored/scored_run.rb
 #
-# Configuration (all optional, via environment):
-#   RLTO_LOCAL     true|false   use a local Ollama model (default true)
-#   RLTO_PROVIDER  name         LLM provider (default: openai for local)
-#   RLTO_MODEL     id           model id (default: qwen3.6:latest for local)
-#   OLLAMA_BASE    url          Ollama OpenAI endpoint (default localhost:11434/v1)
+# Configuration (all optional, via environment; examples/.envrc sets these for you):
+#   RLTO_LOCAL     true|false   use a local LM Studio model (default true)
+#   RLTO_PROVIDER  name         LLM provider label (default: lms for local)
+#   RLTO_MODEL     id           model id (default: qwen/qwen3.8-27b for local)
+#   LMS_BASE_URL   url          LM Studio OpenAI-compatible endpoint (default localhost:1234/v1)
 # ===========================================================================
 
 require "fileutils"
-require "logger"
 require "open3"
-require "net/http"
 
 # Make the example runnable straight from the repo during development, with or
 # without `bundle exec`. (When the gem is installed normally these paths don't
@@ -55,49 +53,24 @@ require "net/http"
   File.expand_path("../../../robot_lab/lib", __dir__) # sibling robot_lab/lib
 ].each { |p| $LOAD_PATH.unshift(p) if Dir.exist?(p) }
 
-require "ruby_llm"
 require "robot_lab"
 require "robot_lab/to"
+require_relative "../common"
 
 # --- configuration ---------------------------------------------------------
 
 LOCAL    = ENV.fetch("RLTO_LOCAL", "true") == "true"
-PROVIDER = ENV.fetch("RLTO_PROVIDER", LOCAL ? "openai" : "anthropic").to_sym
-MODEL    = ENV.fetch("RLTO_MODEL", LOCAL ? "qwen3.6:latest" : "claude-sonnet-4-6")
-OLLAMA   = ENV.fetch("OLLAMA_BASE", "http://localhost:11434/v1")
+PROVIDER = ENV.fetch("RLTO_PROVIDER", LOCAL ? "lms" : "anthropic").to_sym
+MODEL    = ENV.fetch("RLTO_MODEL", LOCAL ? "qwen/qwen3.8-27b" : "claude-sonnet-4-6")
 
-TOTAL_TESTS = 9 # the seeded suite has 9 test methods — the target
-
-# Route RubyLLM's :openai provider at Ollama's OpenAI-compatible endpoint for a
-# local run (non-streaming, since Ollama suppresses tool calls when streaming).
-def configure_local!
-  RubyLLM.configure do |c|
-    c.openai_api_base = OLLAMA
-    c.openai_api_key  = "ollama"
-    c.request_timeout = 600
-  end
-  RubyLLM.logger.level = Logger::ERROR
-  RubyLLM.models.refresh!
-rescue StandardError => e
-  warn "warning: could not refresh Ollama models (#{e.class}: #{e.message})"
-end
+# ruby_llm has no native "lms" adapter. "lms" is this example's friendly label for
+# "a local LM Studio model"; setup (common.rb) resolves it to the :lms provider
+# adapter pointed at LM Studio, starting the server and loading MODEL as needed.
+# Everything passed to RobotLab uses the resolved provider; PROVIDER itself is
+# kept only for display.
+LLM_PROVIDER = setup(provider: PROVIDER, model: MODEL)
 
-def preflight_local!
-  uri = URI.join(OLLAMA, "models")
-  Net::HTTP.start(uri.host, uri.port, open_timeout: 2, read_timeout: 2) { |h| h.get(uri.request_uri) }
-rescue StandardError
-  abort <<~MSG
-    Cannot reach an Ollama server at #{OLLAMA}.
-    Start it and pull a tool-capable model first:
-
-      ollama serve &
-      ollama pull #{MODEL}
-
-    Or run against a cloud model:
-      RLTO_LOCAL=false RLTO_PROVIDER=anthropic RLTO_MODEL=claude-sonnet-4-6 \\
-        ANTHROPIC_API_KEY=sk-... ruby #{File.basename(__FILE__)}
-  MSG
-end
+TOTAL_TESTS = 9 # the seeded suite has 9 test methods — the target
 
 # --- sandbox repository ----------------------------------------------------
 
@@ -290,15 +263,10 @@ OBJECTIVE = <<~OBJ.strip
   Call submit_result each iteration describing what you improved.
 OBJ
 
-if LOCAL
-  preflight_local!
-  configure_local!
-end
-
 clean_slate!
 sandbox = make_sandbox
 puts "Project dir:     #{sandbox}"
-puts "Provider/model:  #{PROVIDER}/#{MODEL} (#{LOCAL ? 'local Ollama' : 'cloud'})"
+puts "Provider/model:  #{PROVIDER}/#{MODEL} (#{LOCAL ? 'local LM Studio' : 'cloud'})"
 puts "Eval:            measured descent — score = passing tests, target #{TOTAL_TESTS}"
 puts "Locked grader:   score.rb, test/roman_numeral_test.rb"
 puts
@@ -308,7 +276,7 @@ RobotLab.on(FeedbackHook)
 Dir.chdir(sandbox) do
   RobotLab::To.run(
     OBJECTIVE,
-    provider:       PROVIDER,
+    provider:       LLM_PROVIDER,
     model:          MODEL,
     local_guards:   LOCAL,
     stream:         !LOCAL,

data/examples/04_prose/README.md

@@ -2,12 +2,12 @@
 
 Demo 03 scores **code** with a deterministic command (passing tests). Prose has no
 `rake coverage`, so this demo uses the **`prose` eval** — a pairwise LLM judge — and
-puts two *different* models in two roles:
+puts two roles on the same local model by default, each independently swappable:
 
 | Role | Model (default) | Job |
 |------|-----------------|-----|
-| **Doer** | `qwen3.6:latest` | writes and improves `guide.md` |
-| **Verifier** (judge) | `gpt-oss:latest` | compares each draft to the last committed one and rules it **better / worse / same** |
+| **Doer** | `qwen/qwen3.8-27b` | writes and improves `guide.md` |
+| **Verifier** (judge) | `qwen/qwen3.8-27b` | compares each draft to the last committed one and rules it **better / worse / same** |
 
 Only a draft the judge rules **better** is committed, so every commit is a genuine
 improvement. There's no absolute target (LLM scores are too noisy to descend), so
@@ -18,25 +18,26 @@ cannot edit the criteria it's judged against.
 ## Run it
 
 ```bash
-ollama pull qwen3.6:latest      # doer
-ollama pull gpt-oss:latest      # verifier / judge
 bundle exec ruby examples/04_prose/prose_run.rb
 ```
 
-Override the models via env: `RLTO_MODEL` (doer), `RLTO_JUDGE_MODEL` (verifier).
+`common.rb` starts the LM Studio server and loads the doer + judge models for
+you if they aren't already running/loaded. Override the models via env:
+`RLTO_MODEL` (doer), `RLTO_JUDGE_MODEL` (verifier).
 
-## Why gpt-oss works as the judge here (but not as a doer)
+## Why the judge can be the same model as the doer
 
-gpt-oss is a reasoning model that, when *offered tools*, tends to call its own
-built-ins (`container.exec`) instead of the provided ones — which makes it a poor
-**doer**. But the **judge** is given **no tools**; it just reads two versions and
-replies `better`/`worse`/`same`. As a pure text responder it's reliable, which is
-exactly the verifier's job. This is the separation-of-duties payoff: the model that
-*decides* is independent of the model that *acts*.
+The **doer** is given the file-editing tools; the **judge** is given **no tools**
+at all — it just reads two versions and replies `better`/`worse`/`same`. As a pure
+text responder it doesn't need to be a stronger or different model to be reliable,
+which is why both roles default to the same local `qwen/qwen3.8-27b`. This is still the
+separation-of-duties payoff: the model that *decides* is called independently of
+the model that *acts*, so swap in a stronger `RLTO_JUDGE_MODEL` if you want a
+tougher judge without touching the doer.
 
 ## The mechanism
 
-`RobotLab::To.run(..., eval: "prose", eval_judge_model: "gpt-oss:latest")` builds an
+`RobotLab::To.run(..., eval: "prose", eval_judge_model: "qwen/qwen3.8-27b")` builds an
 `Evals::Prose`. Each iteration, after the doer edits `guide.md`, the eval diffs the
 working tree against the parent commit, shows both versions plus the spec to the
 judge model, and maps its verdict onto `Score#improved`. Commit on *better*, roll

data/examples/04_prose/prose_run.rb

@@ -16,9 +16,10 @@
 #             section. The run ends when every outline section has a READY file.
 #   Finally the approved sections are assembled into guide.md.
 #
-# Two models, two roles:
-#   DOER     (default qwen3.6:latest) — writes the outline and the sections
-#   VERIFIER (default gpt-oss:latest) — the judge; grades each artifact absolutely
+# Two models, two roles (the same local model by default, but independently
+# configurable — pass --judge-model / RLTO_JUDGE_MODEL for a stronger judge):
+#   DOER     (default qwen/qwen3.8-27b) — writes the outline and the sections
+#   VERIFIER (default qwen/qwen3.8-27b) — the judge; grades each artifact absolutely
 #
 # The judge writes its feedback to REVIEW.md (git-ignored in the sandbox); the
 # doer is told to read REVIEW.md each iteration. write_guard is disabled for the
@@ -27,18 +28,17 @@
 # ---------------------------------------------------------------------------
 # Run it
 # ---------------------------------------------------------------------------
-#   ollama pull qwen3.6:latest      # doer
-#   ollama pull gpt-oss:latest      # verifier / judge
 #   bundle exec ruby examples/04_prose/prose_run.rb
 #
+# common.rb starts the LM Studio server and loads the doer + judge models for
+# you if they aren't already running/loaded.
+#
 # Env: RLTO_MODEL (doer), RLTO_JUDGE_MODEL (verifier), RLTO_TOPIC, RLTO_LOCAL,
-#      RLTO_PROVIDER, OLLAMA_BASE.
+#      RLTO_PROVIDER, LMS_BASE_URL. (examples/.envrc sets these for you)
 # ===========================================================================
 
 require "fileutils"
-require "logger"
 require "open3"
-require "net/http"
 
 [
   File.expand_path("../../lib", __dir__),
@@ -51,38 +51,27 @@ require "net/http"
 PROMPTS_DIR = File.expand_path("prompts_dir", __dir__)
 ENV["ROBOT_LAB_TEMPLATE_PATH"] = PROMPTS_DIR
 
-require "ruby_llm"
 require "robot_lab"
 require "robot_lab/to"
+require_relative "../common"
 RobotLab.reload_config! if RobotLab.respond_to?(:reload_config!)
 
 # --- configuration ---------------------------------------------------------
 
 LOCAL       = ENV.fetch("RLTO_LOCAL", "true") == "true"
-PROVIDER    = ENV.fetch("RLTO_PROVIDER", LOCAL ? "openai" : "anthropic").to_sym
-DOER_MODEL  = ENV.fetch("RLTO_MODEL", LOCAL ? "qwen3.6:latest" : "claude-sonnet-4-6")
-JUDGE_MODEL = ENV.fetch("RLTO_JUDGE_MODEL", LOCAL ? "gpt-oss:latest" : "claude-sonnet-4-6")
-OLLAMA      = ENV.fetch("OLLAMA_BASE", "http://localhost:11434/v1")
+PROVIDER    = ENV.fetch("RLTO_PROVIDER", LOCAL ? "lms" : "anthropic").to_sym
+DOER_MODEL  = ENV.fetch("RLTO_MODEL", LOCAL ? "qwen/qwen3.8-27b" : "claude-sonnet-4-6")
+JUDGE_MODEL = ENV.fetch("RLTO_JUDGE_MODEL", LOCAL ? "qwen/qwen3.8-27b" : "claude-sonnet-4-6")
 TOPIC       = ENV.fetch("RLTO_TOPIC", "writing good Git commit messages")
 
-def configure_local!
-  RubyLLM.configure do |c|
-    c.openai_api_base = OLLAMA
-    c.openai_api_key  = "ollama"
-    c.request_timeout = 600
-  end
-  RubyLLM.logger.level = Logger::ERROR
-  RubyLLM.models.refresh!
-rescue StandardError => e
-  warn "warning: could not refresh Ollama models (#{e.class}: #{e.message})"
-end
-
-def preflight_local!
-  uri = URI.join(OLLAMA, "models")
-  Net::HTTP.start(uri.host, uri.port, open_timeout: 2, read_timeout: 2) { |h| h.get(uri.request_uri) }
-rescue StandardError
-  abort "Cannot reach Ollama at #{OLLAMA}. Start it and pull #{DOER_MODEL} + #{JUDGE_MODEL}."
-end
+# ruby_llm has no native "lms" adapter. "lms" is this example's friendly label for
+# "a local LM Studio model"; setup (common.rb) resolves it to the :lms provider
+# adapter pointed at LM Studio, starting the server and loading each model as
+# needed -- once for the doer, again for the judge (a no-op if they're the same
+# model, or if it's already loaded). Everything passed to RobotLab uses the
+# resolved provider; PROVIDER itself is kept only for display.
+LLM_PROVIDER = setup(provider: PROVIDER, model: DOER_MODEL)
+setup(provider: PROVIDER, model: JUDGE_MODEL)
 
 # --- the judge (absolute grader) -------------------------------------------
 
@@ -90,7 +79,7 @@ end
 # prompt is a robot_lab template (prompts_dir/judge.md).
 # @return [Array(Boolean, String)] [ready?, feedback]
 def grade(criteria, text)
-  judge = RobotLab.build(name: "judge", model: JUDGE_MODEL, provider: PROVIDER, template: :judge)
+  judge = RobotLab.build(name: "judge", model: JUDGE_MODEL, provider: LLM_PROVIDER, template: :judge)
   message = RobotLab.render_template(:grade_message, criteria: criteria, artifact: text)
   reply = judge.run(message).last_text_content.to_s
   ready = reply.match?(/\bREADY\b/i) && !reply.match?(/NEEDS_WORK/i)
@@ -255,11 +244,6 @@ end
 
 # --- main ------------------------------------------------------------------
 
-if LOCAL
-  preflight_local!
-  configure_local!
-end
-
 clean_slate!
 sandbox = make_sandbox
 puts "Project dir:     #{sandbox}"
@@ -271,7 +255,7 @@ puts
 RobotLab.on(FeedbackHook)
 
 common = {
-  provider: PROVIDER, model: DOER_MODEL, local_guards: LOCAL, stream: !LOCAL,
+  provider: LLM_PROVIDER, model: DOER_MODEL, local_guards: LOCAL, stream: !LOCAL,
   run_dir: RUN_DIR, write_guard: false, require_improvement: false
 }