robot_lab 0.2.7 → 0.3.0

data/examples/15_memory_network_and_bus/output/windows_draft.md

@@ -1,7 +1,7 @@
 # win_writer Draft
 
-Windows is the strongest all-around choice for a home AI research lab because it gives you the best combination of raw GPU support, hardware flexibility, and practical developer workflow. For LLM fine-tuning, image generation, and local inference, NVIDIA CUDA support on Windows is first-class: PyTorch, TensorFlow, xFormers, bitsandbytes, TensorRT, ONNX Runtime, and popular tools like Ollama, LM Studio, ComfyUI, AUTOMATIC1111, and Stable Diffusion WebUI all have strong Windows paths. If you want the highest-performance consumer GPUs for AI work, Windows pairs especially well with NVIDIA RTX hardware, from a single 4070 Ti Super up to multi-GPU prosumer setups. And if you need Linux-native scripts or package workflows, WSL2 gives you a near-seamless Ubuntu environment on the same machine, so you can run Hugging Face Transformers, PEFT, DeepSpeed, vLLM, llama.cpp, JupyterLab, and CUDA-enabled Linux tooling without giving up native Windows apps.
+Windows gives a home AI research lab the broadest practical foundation, especially when you need NVIDIA CUDA performance without sacrificing access to Linux-centric tooling. With a native Windows environment, you get first-class NVIDIA driver and CUDA support, making it easy to run PyTorch, Hugging Face Transformers, PEFT/LoRA fine-tuning scripts, TensorBoard, and local inference stacks such as Ollama, llama.cpp, or text-generation-webui. At the same time, WSL2 gives you a near-native Linux userspace with GPU passthrough, so you can work in Ubuntu, Docker, or containerized pipelines while still using Windows-native tools like Visual Studio Code, Windows Terminal, and Docker Desktop. That combination is rare: you get the Linux ecosystem that much of the AI community expects, without being locked out of the desktop experience, hardware compatibility, and driver maturity that Windows still handles best.
 
-Windows also wins on hardware compatibility and ecosystem breadth. A home lab often mixes gaming-class GPUs, high-core-count CPUs, fast NVMe storage, USB devices, capture cards, and sometimes unusual motherboard or networking gear; Windows consistently offers the widest driver support and easiest setup across that mix. Beyond CUDA, Windows also supports DirectML, which broadens acceleration options on AMD and Intel hardware for local inference and experimentation. On the tooling side, it integrates cleanly with Visual Studio Code, Visual Studio, Docker Desktop, PowerShell, Windows Terminal, Git for Windows, and enterprise-friendly tools for remote access, file sharing, backup, and virtualization. In practice, that means you can fine-tune a LoRA in WSL2, monitor GPUs with native Windows utilities, manage datasets on NTFS storage, launch ComfyUI or LM Studio from the desktop, and still have access to familiar scripting and automation.
+For image generation and local inference, Windows is especially convenient because it supports both CUDA and DirectML paths. If you are using an NVIDIA GPU, you can run Stable Diffusion WebUI, ComfyUI, InvokeAI, or SD.Next with strong CUDA backend support, then move to ONNX Runtime, DirectML, or OpenVINO when you need broader hardware flexibility. For AMD or Intel GPUs, DirectML and ONNX Runtime can still provide a usable local inference stack, while the widest consumer and workstation GPU selection on Windows means you can build a high-VRAM lab without needing a single vendor ecosystem. That matters for a home setup: you can mix high-end NVIDIA cards, consumer accelerators, large local SSDs, and Windows-native management tools while keeping the same machine useful for everyday work.
 
-Just as important, Windows has massive community support for home AI builders. Most consumer AI guides now assume either native Windows or Windows plus WSL2, especially for Stable Diffusion workflows, local LLM front ends, and single-node fine-tuning recipes. Troubleshooting is easier when there are abundant guides for CUDA driver versions, PyTorch wheels, Flash Attention builds, and model-serving stacks on common RTX cards. For someone building a serious home AI lab, Windows offers the most practical balance: top-tier NVIDIA performance, Linux compatibility when you need it, broad hardware support, and a mature tool ecosystem that scales from casual experimentation to disciplined research workflows.
+The software ecosystem and community support also favor Windows for a hybrid lab workflow. You can develop in Windows-native Python environments, use Miniconda or PyCharm, and run the same CUDA-accelerated PyTorch and Hugging Face workflows that are common in production, while falling back to WSL2 when a package, dataset, or framework expects a Linux environment. The result is a lab that is flexible rather than ideological: CUDA when performance and compatibility are priority one, WSL2 when Linux tooling is expected, DirectML/ONNX when hardware breadth matters, and a large Windows/NVIDIA/Python community to lean on when debugging drivers, VRAM issues, or fine-tuning pipelines. For a home LLM fine-tuning, image generation, and local inference setup, that balance is exactly why Windows is such a strong choice.

data/examples/16_writers_room/tools.rb

@@ -23,8 +23,8 @@ class BroadcastTool < RobotLab::Tool
               "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
+  parameter :message, type: "string",
+        description: "What to say to the room", required: true
 
   def execute(message:)
     log&.info("#{robot.name} TOOL broadcast (#{message.length} chars)")
@@ -42,10 +42,10 @@ class DirectMessageTool < RobotLab::Tool
               "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
+  parameter :to, type: "string",
+        description: "Name of the writer to message", required: true
+  parameter :message, type: "string",
+        description: "What to say", required: true
 
   def execute(to:, message:)
     log&.info("#{robot.name} TOOL direct_message -> #{to} (#{message.length} chars)")
@@ -63,8 +63,8 @@ class ReadMemoryTool < RobotLab::Tool
               "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
+  parameter :key, type: "string",
+        description: "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)
@@ -86,10 +86,10 @@ class WriteMemoryTool < RobotLab::Tool
               "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
+  parameter :key, type: "string",
+        description: "Memory key (e.g. story_bible, outline, claims, chapter_1)", required: true
+  parameter :value, type: "string",
+        description: "Content to store", required: true
 
   def execute(key:, value:)
     log&.info("#{robot.name} TOOL write_memory :#{key} (#{value.length} chars)")
@@ -124,8 +124,8 @@ class SpawnWriterTool < RobotLab::Tool
   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
+  parameter :name, type: "string",
+        description: "Name for the new writer (e.g. writer_4)", required: true
 
   def execute(name:)
     log&.info("#{robot.name} TOOL spawn_writer '#{name}'")

data/examples/19_token_tracking.rb

@@ -14,7 +14,7 @@
 #   naturally increase as conversation context accumulates.
 #   Use a fresh robot.build when you need a genuinely fresh context.
 #
-# Ollama reports usage counts like the hosted providers do, so the tracking
+# LM Studio reports usage counts like the hosted providers do, so the tracking
 # API behaves identically — only the price per token differs. Token counts are
 # zero for providers that don't report usage data.
 #
@@ -23,7 +23,7 @@
 
 require_relative "common"
 
-# Cost model. A local Ollama model bills nothing, so the interesting number is
+# Cost model. A local LM Studio model bills nothing, so the interesting number is
 # what the same traffic WOULD have cost on a hosted model — set RATE_INPUT_CPM
 # and RATE_OUTPUT_CPM to your provider's $-per-1M-token rates to see it.
 # Defaults are zero: local inference is free.

data/examples/20_circuit_breaker.rb

@@ -39,9 +39,9 @@ class MultiStepProcessor < RubyLLM::Tool
     the status is "complete".
   DESC
 
-  param :step_number,
+  parameter :step_number,
         type: "integer",
-        desc: "Which step to execute. Start at 1, increment by 1 each call."
+        description: "Which step to execute. Start at 1, increment by 1 each call."
 
   TOTAL_STEPS = 50  # far more than any sensible max_tool_rounds
 
@@ -125,7 +125,7 @@ section "Part 3: No Circuit Breaker — Task Terminates Naturally"
 
 class SingleStep < RubyLLM::Tool
   description "Doubles a number and returns the result immediately."
-  param :value, type: "integer", desc: "The number to double"
+  parameter :value, type: "integer", description: "The number to double"
 
   def execute(value:)
     { result: value * 2, status: "complete" }

data/examples/22_context_compression.rb

@@ -156,7 +156,7 @@ puts "cheaper robot does the summarizing for the medium-relevance band."
 show_code <<~RUBY
   summarizer_bot = RobotLab.build(
     name:          "summarizer",
-    provider:      "ollama",
+    provider:      "lms",
     model:         "qwen2.5:7b",
     system_prompt: "Summarize the following text in one sentence."
   )

data/examples/27_incident_response/README.md

@@ -0,0 +1,65 @@
+# Example 27: Production Incident War Room
+
+A simulated payment-service outage, used to demonstrate RobotLab's Phase 5
+infrastructure features: **reactive memory**, **BusPoller serialized
+delivery**, and **poller groups**.
+
+## What it does
+
+A network runs four robots against one incident ("elevated HTTP 500s, p99
+latency spiked to 8s"):
+
+- **Three SRE scouts** (`db_scout`, `net_scout`, `app_scout`) investigate the
+  database, network, and application layers in parallel. Each makes one LLM
+  call, writes its two-sentence finding to shared **reactive memory**
+  (`:db_finding`, `:net_finding`, `:app_finding`), and broadcasts a status
+  line to the war room over TypedBus.
+- **The war room** receives those bus messages through **BusPoller**, which
+  serializes delivery — if two scouts finish at the same instant, their
+  updates queue and are processed one at a time, in arrival order, with no
+  re-entrancy and nothing dropped.
+- **The incident commander** depends on all three scouts and blocks on
+  `memory.get(:db_finding, :net_finding, :app_finding, wait: 60)` — an
+  IO.pipe-backed waiter woken by `IO.select`, so there is no busy-wait and it
+  cooperates with Async. When all findings land it makes one synthesis call
+  and writes a 3-5 bullet action plan.
+
+Also on display:
+
+- **Poller groups** — the scouts run in `poller_group: :investigation`, the
+  commander in `:command`, declared per task on the network.
+- **Memory subscriptions** — a `memory.subscribe` callback prints a line as
+  each finding is written.
+- **Timeout degradation** — `Memory#get(wait:)` raises
+  `RobotLab::AwaitTimeout` rather than returning a sentinel; the commander
+  rescues it and re-reads without `wait:`, so a slow scout degrades the
+  report instead of killing the run.
+
+## How to run
+
+From the gem root (an LM Studio server must be running — `lms server start`;
+provider/model come from `examples/common.rb`):
+
+```bash
+bundle exec ruby examples/27_incident_response/incident_response.rb
+```
+
+Note that `examples/run_all.rb` does **not** include this demo — it only runs
+the top-level `NN_*.rb` files, so run it explicitly as above.
+
+The run makes four LLM calls (three scout diagnoses plus the commander's
+synthesis), so expect a few minutes on the default local model;
+`LLM_PROFILE=small` shortens it.
+
+## Output
+
+- Console: the network graph, each memory write as it happens, the war-room
+  updates in BusPoller delivery order, the scouts' findings, and the final
+  action plan.
+- `output/incident_report.md` — the commander's incident action plan.
+
+## Files
+
+- `incident_response.rb` — the whole demo: `SREScout`, `WarRoom`, and
+  `IncidentCommander` robot classes plus network wiring and the run itself
+- `output/` — where the incident report is written

data/examples/28_mcp_discovery.rb

@@ -12,7 +12,7 @@
 # == Key config
 #
 #   robot = RobotLab.build(
-#     provider: "ollama", model: "qwen3.6:latest",
+#     provider: "lms", model: "qwen/qwen3.8-27b",
 #     mcp_discovery: true,    # ← enables semantic filtering
 #     mcp: [ ... ]            # ← candidate servers, each with :description
 #   )
@@ -95,7 +95,7 @@ section "mcp_discovery: true on a Robot"
 show_code <<~RUBY
   robot = RobotLab.build(
     name:          "assistant",
-    provider:      "ollama",
+    provider:      "lms",
     model:         "qwen3.6:latest",
     mcp_discovery: true,
     mcp: [

data/examples/29_ractor_tools.rb

@@ -46,7 +46,7 @@ end
 class WordStatsTool < TextTool
   description "Count words, sentences, and average word length"
 
-  param :text, type: :string, desc: "Text to analyze"
+  parameter :text, type: :string, description: "Text to analyze"
 
   def execute(text:)
     words     = text.scan(/\b\w+\b/)
@@ -61,7 +61,7 @@ end
 class ReadabilityTool < TextTool
   description "Estimate words-per-sentence and long-word density"
 
-  param :text, type: :string, desc: "Text to analyze"
+  parameter :text, type: :string, description: "Text to analyze"
 
   def execute(text:)
     words      = text.scan(/\b\w+\b/)
@@ -86,7 +86,7 @@ class HeavyDigestTool < TextTool
 
   ROUNDS = 500_000
 
-  param :text, type: :string, desc: "Seed text"
+  parameter :text, type: :string, description: "Seed text"
 
   def execute(text:)
     digest = text
@@ -102,7 +102,7 @@ class RequestCounterTool < RobotLab::Tool
 
   @@hits = 0   # mutable class variable — Ractor workers cannot access this
 
-  param :text, type: :string, desc: "Text to count"
+  parameter :text, type: :string, description: "Text to count"
 
   def execute(text:)
     @@hits += 1

data/examples/30_ractor_network.rb

@@ -190,7 +190,7 @@ puts
 
 unless ENV["RUN_LIVE"]
   section "Part 3: Live LLM Run"
-  puts "   Set RUN_LIVE=1 (with Ollama running) to attempt the real pipeline."
+  puts "   Set RUN_LIVE=1 (with LM Studio running) to attempt the real pipeline."
   puts "   Expected behavior: headline_finder, background_brief, and"
   puts "   fact_checker run in parallel; report_writer follows."
   puts
@@ -204,7 +204,7 @@ unless ENV["RUN_LIVE"]
   exit 0
 end
 
-require_ollama!
+require_lms!
 
 section "Part 3: Live LLM Run (RUN_LIVE set)"
 

data/examples/33_stock_predictor.rb

@@ -14,7 +14,7 @@
 # Prerequisites:
 #   gem install redis
 #   Redis server running on localhost:6379
-#   Ollama running with the model from common.rb pulled
+#   LM Studio running with the models from common.rb downloaded
 #
 # Usage:
 #   ruby examples/33_stock_predictor.rb
@@ -119,12 +119,12 @@ class AdjustParameters < RobotLab::Tool
   description "Adjust one predictor parameter to improve future prediction accuracy. " \
               "Make at most one or two targeted changes per window."
 
-  param :parameter, type: "string",
-    desc: "Parameter to adjust: sma_window, sma_std_multiplier, ema_alpha, ema_vol_multiplier, sma_weight"
-  param :value, type: "number",
-    desc: "New value (sma_window: 3-30 int; std/vol multipliers: 0.5-4.0; ema_alpha: 0.05-0.5; sma_weight: 0.0-1.0)"
-  param :reasoning, type: "string",
-    desc: "Why this change should reduce prediction error"
+  parameter :parameter, type: "string",
+    description: "Parameter to adjust: sma_window, sma_std_multiplier, ema_alpha, ema_vol_multiplier, sma_weight"
+  parameter :value, type: "number",
+    description: "New value (sma_window: 3-30 int; std/vol multipliers: 0.5-4.0; ema_alpha: 0.05-0.5; sma_weight: 0.0-1.0)"
+  parameter :reasoning, type: "string",
+    description: "Why this change should reduce prediction error"
 
   LIMITS = {
     "sma_window"         => { min: 3,    max: 30,  integer: true  },
@@ -204,7 +204,7 @@ puts "Warmup     : #{PredictorConfig.sma_window} ticks"
 puts "Press Ctrl-C to stop."
 puts "-" * 60
 
-require_ollama!
+require_lms!
 
 redis  = Redis.new
 prices = []

data/examples/35_hooks.rb

@@ -129,7 +129,7 @@ end
 
 class HookDemoTool < RobotLab::Tool
   description "Returns a deterministic hook demo value"
-  param :label, type: "string", desc: "The label to echo"
+  parameter :label, type: "string", description: "The label to echo"
 
   def execute(label:)
     { label: label, status: "handled by HookDemoTool" }
@@ -187,7 +187,7 @@ class HookDemo
 
     puts "  provider=#{LLM[:default].provider}  model=#{LLM[:default].model}\n\n"
 
-    # with_model alone would leave the provider unset, and an Ollama model is
+    # with_model alone would leave the provider unset, and an LM Studio model is
     # not in RubyLLM's registry — pass provider and model together.
     robot = RobotLab.build(
       name: "loop_demo_robot",
@@ -224,7 +224,7 @@ class HookDemo
   def run_tool
     section "Tool Call Hooks"
     tool   = HookDemoTool.new
-    result = tool.call({ "label" => "tool hook payload" })
+    result = tool.call(**{ "label" => "tool hook payload" })
     puts "Tool result: #{result.inspect}"
   end
 

data/examples/README.md

@@ -2,6 +2,15 @@
 
 Working demonstrations of RobotLab features, from single-robot basics to multi-robot orchestration and message bus communication.
 
+> **A note on performance:** how fast (and how well) these demos run depends
+> almost entirely on which provider and model you point them at. A large model
+> served locally on consumer hardware can take a minute or more per LLM call,
+> while a small local model or a hosted API answers in seconds — and smaller
+> models may also give noticeably weaker answers on the multi-robot demos.
+> Wall-clock times you see will differ from anyone else's; tune the
+> provider/model in `common.rb` (or via `LLM_PROFILE`) to trade speed against
+> quality.
+
 ## Prerequisites
 
 - Ruby >= 3.2
@@ -83,8 +92,16 @@ bundle exec rake examples:all
 
 # Run directly
 bundle exec ruby examples/01_simple_robot.rb
+
+# Run every demo serially with a banner between each (works from any cwd)
+examples/run_all.rb
 ```
 
+`run_all.rb` executes every executable `NN_*.rb` demo in order, announcing
+each one with a banner so the outputs stay separated. Ctrl-C kills only the
+demo that is currently running — the runner notes the interruption and moves
+on to the next demo.
+
 ## Tools require `tools: :inherit` at run time
 
 This trips up everyone once. `Robot#run` defaults to `tools: :none`, which

data/examples/common.rb

@@ -1,33 +1,64 @@
 # frozen_string_literal: true
 
+# The examples are runnable directly (./01_simple_robot.rb) as well as via
+# bundle exec. Without bundler/setup, bare requires let RubyGems activate the
+# newest installed json (3.x), which conflicts with ruby_llm's json (< 3) pin;
+# the lockfile pins json 2.x, so honor it in both invocation styles.
+#
+# The workspace .envrc exports BUNDLE_GEMFILE as a RELATIVE path ("Gemfile" or
+# "Gemfile.local"), which bundler resolves against the cwd — so a demo run
+# from examples/ or a subdirectory demo run from its own directory would look
+# for a Gemfile there. Anchor the basename to the gem root before bundler
+# sees it, preserving the prod/dev (Gemfile vs Gemfile.local) choice.
+ENV["BUNDLE_GEMFILE"] = File.expand_path(
+  "../#{File.basename(ENV.fetch("BUNDLE_GEMFILE", "Gemfile"))}", __dir__
+)
+require "bundler/setup"
+
 require "logger"
 
 # Fallback for when direnv has not activated examples/.envrc
 ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
 
 require_relative "../lib/robot_lab"
+require "ruby_llm/providers/lms"
+
+# robot_lab's dependencies load parts of ActiveSupport, so amazing_print 3.0
+# sees the constant and loads its ActiveSupport extension, which at require
+# time calls ActiveSupport.try and reads ActiveSupport::LogSubscriber —
+# neither of which those parts provide. Load both up front so any demo can
+# `require "amazing_print"` safely.
+require "active_support/core_ext/object/try"
+require "active_support/log_subscriber"
 
 # ── Local LLM Configuration ───────────────────────────────────────────────────
 #
-# Every example runs against a LOCAL model served by Ollama. No API keys, no
-# network egress, no per-token cost. Pull the model once before running:
+# Every example runs against a LOCAL model served by LM Studio through the
+# ruby_llm-providers-lms gem (provider :lms). No API keys, no network egress,
+# no per-token cost. Start the server and download the models once:
+#
+#   lms server start
+#   lms get qwen/qwen3.8-27b
+#   lms get openai/gpt-oss-20b
 #
-#   ollama pull qwen3.6
+# Model choice: qwen/qwen3.8-27b for complex activities (tools, structured
+# output, multi-robot reasoning — it honors tool_choice and schemas), and
+# openai/gpt-oss-20b for simpler items (plain chat, streaming).
 #
-# Ollama models are not in RubyLLM's model registry, so a `provider:` must be
-# supplied alongside `model:` — that is what makes RubyLLM skip the registry
-# lookup (see Robot#initialize, which sets assume_model_exists when provider is
-# given). Use the `llm_opts` helper below so every robot gets both.
+# LM Studio models are not in RubyLLM's model registry, so a `provider:` must
+# be supplied alongside `model:` — that is what makes RubyLLM skip the
+# registry lookup (see Robot#initialize, which sets assume_model_exists when
+# provider is given). Use the `llm_opts` helper below so every robot gets both.
 
 LlmConfig = Data.define(:provider, :model)
 
 LLM = {
-  default: LlmConfig.new(provider: "ollama", model: "qwen3.6:latest"),
-  small:   LlmConfig.new(provider: "ollama", model: "qwen2.5:7b"),
-  large:   LlmConfig.new(provider: "ollama", model: "llama3.3:latest")
+  default: LlmConfig.new(provider: "lms", model: "qwen/qwen3.8-27b"),
+  small:   LlmConfig.new(provider: "lms", model: "openai/gpt-oss-20b"),
+  large:   LlmConfig.new(provider: "lms", model: "qwen/qwen3.8-27b")
 }.freeze
 
-OLLAMA_API_BASE = ENV.fetch("OLLAMA_API_BASE", "http://localhost:11434/v1")
+LMS_API_BASE = ENV.fetch("LMS_API_BASE", "http://localhost:1234/v1")
 
 # ORDER MATTERS. The first touch of RobotLab.config runs Config#after_load,
 # which calls RubyLLM.configure itself and would clobber anything set before
@@ -37,9 +68,9 @@ RobotLab.configure do |c|
 end
 
 RubyLLM.configure do |c|
-  c.logger          = Logger.new(File::NULL)
-  c.default_model   = LLM[:default].model
-  c.ollama_api_base = OLLAMA_API_BASE
+  c.logger        = Logger.new(File::NULL)
+  c.default_model = LLM[:default].model
+  c.lms_api_base  = LMS_API_BASE
 
   # A large local model on consumer hardware is far slower than a hosted API,
   # and robot_lab's bundled 120s default is comfortably exceeded by a long
@@ -67,7 +98,7 @@ end
 
 # Provider + model keyword pair for RobotLab.build / Robot.new.
 #
-# Both are required for a local Ollama model. Splat it into any robot
+# Both are required for a local LM Studio model. Splat it into any robot
 # constructor:
 #
 #   RobotLab.build(name: "helper", **llm_opts)          # honors LLM_PROFILE
@@ -80,19 +111,20 @@ def llm_opts(key = nil)
   { provider: cfg.provider, model: cfg.model }
 end
 
-# Fail fast with an actionable message when Ollama isn't reachable, instead of
-# letting every example die inside an HTTP adapter.
-def require_ollama!
+# Fail fast with an actionable message when LM Studio isn't reachable,
+# instead of letting every example die inside an HTTP adapter.
+def require_lms!
   require "net/http"
-  uri = URI(OLLAMA_API_BASE.sub(%r{/v1/?$}, "") + "/api/tags")
+  uri = URI("#{LMS_API_BASE.sub(%r{/v1/?\z}, '')}/v1/models")
   Net::HTTP.start(uri.host, uri.port, open_timeout: 2, read_timeout: 2) { |h| h.get(uri.request_uri) }
 rescue StandardError => e
   abort <<~ERROR
-    Cannot reach Ollama at #{OLLAMA_API_BASE} (#{e.class}).
+    Cannot reach LM Studio at #{LMS_API_BASE} (#{e.class}).
 
-    Start it and pull the model used by the examples:
-      ollama serve
-      ollama pull #{LLM[:default].model.sub(/:latest\z/, "")}
+    Start the server and download the models used by the examples:
+      lms server start
+      lms get #{LLM[:default].model}
+      lms get #{LLM[:small].model}
   ERROR
 end
 

data/examples/run_all.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Runs every executable NN_*.rb demo in this directory serially, printing a
+# banner to STDOUT before each one so the outputs are easy to tell apart.
+
+module RunAll
+  module_function
+
+  # Executable NN_*.rb demos in +dir+, in numeric order.
+  def demo_files(dir = __dir__)
+    Dir.glob(File.join(dir, "[0-9][0-9]_*.rb"))
+       .select { File.executable?(it) }
+       .sort
+  end
+
+  def banner(path)
+    bar = "=" * 70
+    <<~BANNER
+
+      #{bar}
+      ==  #{File.basename(path)}
+      #{bar}
+    BANNER
+  end
+
+  # Absolute path to the gem root's Gemfile, honoring the prod/dev choice
+  # (Gemfile vs Gemfile.local) carried by BUNDLE_GEMFILE. The inherited value
+  # is relative, so left alone it would resolve against the demo's cwd.
+  def bundle_gemfile(dir = __dir__)
+    name = File.basename(ENV.fetch("BUNDLE_GEMFILE", "Gemfile"))
+    File.expand_path("../#{name}", dir)
+  end
+
+  # Runs one demo with this Ruby interpreter; returns true on success.
+  def run_demo(path)
+    system({ "BUNDLE_GEMFILE" => bundle_gemfile }, RbConfig.ruby, path)
+  end
+
+  # True when the last demo was killed by Ctrl-C (SIGINT).
+  def interrupted?(status = Process.last_status)
+    !status.nil? && status.signaled? && status.termsig == Signal.list["INT"]
+  end
+
+  # Ctrl-C reaches the whole foreground process group. A proc trap (unlike
+  # "IGNORE") is reset to DEFAULT in the exec'd child, so the demo dies while
+  # this runner survives and moves on to the next one.
+  def run(files = demo_files)
+    previous = trap("INT") { nil }
+    files.each do |file|
+      puts banner(file)
+      run_demo(file)
+      puts "--  #{File.basename(file)} interrupted (Ctrl-C); moving on" if interrupted?
+    end
+  ensure
+    trap("INT", previous || "DEFAULT")
+  end
+end
+
+RunAll.run if $PROGRAM_NAME == __FILE__

data/lib/robot_lab/agent_skill_catalog.rb

@@ -52,6 +52,7 @@ module RobotLab
       @mutex.synchronize { load_skills! unless @loaded }
     end
 
+    # :reek:TooManyStatements -- linear directory scan; each guard clause skips a non-skill entry.
     def load_skills!
       @loaded = true
       return unless @skills_root.directory?

data/lib/robot_lab/ask_user.rb

@@ -33,10 +33,12 @@ module RobotLab
   #
   class AskUser < Tool
     description "Ask the user a question and wait for their typed response"
-    param :question, type: "string",  desc: "The question to ask the user"
-    param :choices,  type: "array",   desc: "Optional list of choices to present", required: false
-    param :default,  type: "string",  desc: "Default value if user presses Enter",  required: false
+    parameter :question, type: "string",  description: "The question to ask the user"
+    parameter :choices,  type: "array",   description: "Optional list of choices to present", required: false
+    parameter :default,  type: "string",  description: "Default value if user presses Enter",  required: false
 
+    # :reek:FeatureEnvy -- rendering and resolving the caller-supplied choices list is this tool's whole job.
+    # :reek:TooManyStatements -- linear prompt/read/resolve terminal interaction.
     def execute(question:, choices: nil, default: nil)
       out = output_io
       label = robot&.name || "Robot"

data/lib/robot_lab/bus_poller.rb

@@ -67,6 +67,7 @@ module RobotLab
     # @param group    [Symbol]  poller group label (informational only)
     # @return [void]
     #
+    # :reek:TooManyStatements -- the queue-or-run decision must stay inside one mutex critical section.
     def enqueue(robot:, delivery:, group: :default)
       should_process = @mutex.synchronize do
         name = robot.name
@@ -124,6 +125,7 @@ module RobotLab
       RobotLab.config.logger.warn("BusPoller: unexpected error: #{e.message}")
     end
 
+    # :reek:TooManyStatements -- pop-under-mutex then process-outside-mutex loop; splitting it would separate the lock from its release.
     def drain_queued_deliveries(robot)
       loop do
         next_delivery = @mutex.synchronize do

data/lib/robot_lab/capabilities.rb

@@ -15,6 +15,8 @@ module RobotLab
 
     attr_reader :fs_read, :fs_write, :network, :timeout, :trust
 
+    # :reek:BooleanParameter -- `network` is a declared capability value (part of the data model), not a mode switch.
+    # :reek:ControlParameter -- `network ? true : false` is boolean coercion of untrusted front-matter input, not behavior selection.
     def initialize(fs_read: [], fs_write: [], network: false, timeout: DEFAULT_TIMEOUT, trust: "external")
       @fs_read  = Array(fs_read).map(&:to_s)
       @fs_write = Array(fs_write).map(&:to_s)
@@ -24,6 +26,7 @@ module RobotLab
     end
 
     # Build from a SKILL.md front matter hash (string or symbol keys).
+    # :reek:ControlParameter -- `front_matter || {}` is a nil-safe default, not control coupling.
     def self.from_front_matter(front_matter)
       fm = front_matter || {}
       new(
@@ -72,6 +75,7 @@ module RobotLab
 
     private
 
+    # :reek:NestedIterators -- 2-deep select/any? over two small path lists is idiomatic Ruby.
     def clamp_paths(requested, allowed)
       roots = expand(allowed)
       expand(requested).select { |p| roots.any? { |r| p == r || p.start_with?("#{r}/") } }