robot_lab 0.2.7 → 0.2.8

data/docs/guides/hooks.md

@@ -1076,6 +1076,128 @@ RobotLab.on(RedactionHook)
 
 ---
 
+## Extension Registration
+
+Hooks inject *behavior* ("do this on these events"). A separate, lighter
+mechanism — **extension registration** — answers a different question: *"is
+optional feature X loaded?"* This is how core lights up conditional behavior
+without depending on, or probing for, the gem that provides it. The two
+mechanisms are orthogonal but commonly used together: a gem registers itself
+(discovery), then wires behavior in via a hook (injection).
+
+### The API
+
+```ruby
+RobotLab.register_extension(:audit, RobotLab::Audit)  # gem announces itself
+RobotLab.extension_loaded?(:audit)                     # => true/false — core's guard
+RobotLab.extension(:audit)                             # => RobotLab::Audit
+RobotLab.loaded_extensions                             # => [:audit, :ractor, ...]
+```
+
+It is deliberately tiny: a `Hash` and four methods. The registered value can be
+the extension's primary module, or just a sentinel when the gem only needs a
+presence flag:
+
+```ruby
+RobotLab.register_extension(:ractor, :ractor_extension_loaded)
+```
+
+### How an Extension Announces Itself
+
+At the bottom of the gem's entry file, after everything it provides is
+defined, guarded so the gem can also load standalone or against an older core:
+
+```ruby
+# robot_lab-audit/lib/robot_lab/audit.rb (tail)
+if defined?(RobotLab) && RobotLab.respond_to?(:register_extension)
+  RobotLab.register_extension(:audit, RobotLab::Audit)
+end
+```
+
+The same one-liner appears verbatim in `robot_lab-document_store`,
+`robot_lab-durable`, `robot_lab-discovery`, etc. Registration last, guarded
+always.
+
+### How Core Consumes It
+
+Core guards optional behavior with `extension_loaded?` instead of scattered
+`defined?` / `respond_to?` probes — one named question, asked in one style:
+
+```ruby
+# tool.rb — only use the Ractor pool when the gem is present
+self.class.ractor_safe? && !self.class.name.nil? && RobotLab.extension_loaded?(:ractor)
+
+# memory.rb — semantic features require the document_store gem
+unless RobotLab.extension_loaded?(:document_store)
+  …
+end
+```
+
+When a guarded feature is *requested* without its extension, core raises a
+helpful error naming the exact gem to add — not a cryptic `NoMethodError`:
+
+```ruby
+# network.rb — parallel_mode: :ractor needs the gem
+def run_with_ractor_scheduler(run_context)
+  unless RobotLab.extension_loaded?(:ractor)
+    raise RobotLab::DependencyError,
+          "parallel_mode: :ractor requires the robot_lab-ractor gem. " \
+          "Add `gem 'robot_lab-ractor'` to your Gemfile."
+  end
+  …
+end
+```
+
+### Version-Skew Tolerance
+
+`robot_lab-a2a` ships a fallback so it works even against a core too old to
+provide the registry API: if `register_extension` isn't defined, the gem
+**defines it** (plus `extension_loaded?`/`extension`) over its own private
+`@_extensions` hash, then registers itself:
+
+```ruby
+module RobotLab
+  @_extensions = {} unless instance_variable_defined?(:@_extensions)
+
+  class << self
+    unless method_defined?(:register_extension) || respond_to?(:register_extension)
+      def register_extension(name, mod) = @_extensions[name.to_sym] = mod
+    end
+    unless method_defined?(:extension_loaded?) || respond_to?(:extension_loaded?)
+      def extension_loaded?(name) = @_extensions.key?(name.to_sym)
+    end
+    # … extension(name) likewise …
+  end
+end
+
+RobotLab.register_extension(:a2a, RobotLab::A2A)
+```
+
+The gem never assumes the core's age; it provides the contract if it must.
+
+### How It Composes with Hooks
+
+- `register_extension(:audit, RobotLab::Audit)` — *"I exist"* (discovery).
+- Inside `Audit.enable(db_path:)` → `RobotLab.on(Hook)` — *"do this on these
+  events"* (behavior).
+
+Two common shapes:
+
+- **Auto-wire at load** — register the extension *and* `RobotLab.on(SomeHook)`
+  at require time (always-on features).
+- **Opt-in enable** — register the extension at load, but expose
+  `enable!`/`enable(...)` that registers the hook on demand
+  (`Audit.enable`, `Narrator.enable!`). Lets the user choose scope/config.
+
+> [!TIP]
+> Design decisions worth stealing: a named capability registry beats
+> duck-typing; core never `require`s an extension — the extension `require`s
+> core and announces itself; a sentinel value works when you only need a
+> presence flag; and using a guarded feature without its gem should raise a
+> helpful error naming the exact gem to add.
+
+---
+
 ## See Also
 
 - [examples/35_hooks.rb](https://github.com/MadBomber/robot_lab/blob/main/examples/35_hooks.rb) — full demo with xyzzy extension, perf timer, LLM response cache, and tracer hooks

data/docs/guides/using-tools.md

@@ -335,13 +335,22 @@ trust: external   # or "core" for trusted, always-unconfined skills
 ---
 ```
 
-Sandboxing itself is **opt-in and off by default** — see the [`sandbox:` config section](../getting-started/configuration.md#skill-script-sandboxing-sandbox-section). When disabled, scripts run exactly as they always have, unconfined. When enabled:
+`Capabilities` (the declaration above) lives in core, but core itself has **no sandboxing
+behavior and no built-in limitations** — a script always runs unconfined via a plain
+`Open3.capture2e`, with no timeout, unless the optional
+[`robot_lab-sandbox`](https://github.com/MadBomber/robot_lab-sandbox) gem is required.
+Requiring it installs `RobotLab::Sandbox::Executor` as `RobotLab::ScriptTool.executor`;
+confinement still stays **opt-in and off by default** from there — see the
+[`sandbox:` config section](../getting-started/configuration.md#skill-script-sandboxing-sandbox-section).
+When enabled:
 
 - The global `sandbox:` config is a **ceiling** (`fs_read`, `fs_write`, `network`, `timeout`); each skill's front matter is its **declared** request. The script actually runs under the **intersection** of the two — a path outside the ceiling's roots is dropped even if the skill declares it, `network` requires both sides to allow it, and `timeout` is the smaller of the two.
 - On macOS, confinement is enforced with a generated `sandbox-exec` (Seatbelt) profile: deny-by-default, with narrow allowances for the interpreter to boot, the granted read/write paths, and (optionally) the network. Notably, `$HOME` is never implicitly readable — SSH keys and cloud credentials stay out of reach unless a path under `$HOME` is explicitly granted.
 - Off macOS, or for any skill declaring `trust: core`, sandboxing is a passthrough — confinement is currently macOS-only and is always skipped for trusted "core" skills regardless of platform.
 - A script that runs past its `timeout` is killed (its whole process group) and reported back to the LLM as a timed-out error rather than hanging the turn.
 
+Full API reference: [robot_lab-sandbox](https://github.com/MadBomber/robot_lab-sandbox).
+
 ## Parameter Types
 
 Define parameters on `RubyLLM::Tool` subclasses using `param`:

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

@@ -37,6 +37,8 @@ module RobotLab
     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
 
+    # :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}/") } }

data/lib/robot_lab/config.rb

@@ -78,6 +78,8 @@ module RobotLab
 
     private
 
+    # :reek:UncommunicativeParameterName -- `c` is the RubyLLM config being configured; conventional here (RuboCop allows it).
+    # :reek:TooManyStatements -- one set_if_present line per supported provider credential; a loop would obscure the env-var mapping.
     def apply_provider_api_keys(c)
       # Fall back to standard provider env vars when not set in config.
       # This lets users set ANTHROPIC_API_KEY (etc.) directly without
@@ -103,6 +105,7 @@ module RobotLab
       set_if_present(c, :vertexai_location, :vertexai_location, 'GOOGLE_CLOUD_LOCATION')
     end
 
+    # :reek:UncommunicativeParameterName -- `c` is the RubyLLM config being configured; conventional here.
     def apply_provider_endpoints(c)
       c.openai_api_base = ruby_llm.openai_api_base if ruby_llm.openai_api_base
       c.gemini_api_base = ruby_llm.gemini_api_base if ruby_llm.gemini_api_base
@@ -111,12 +114,14 @@ module RobotLab
       c.xai_api_base = ruby_llm.xai_api_base if ruby_llm.xai_api_base
     end
 
+    # :reek:UncommunicativeParameterName -- `c` is the RubyLLM config being configured; conventional here.
     def apply_openai_options(c)
       c.openai_organization_id = ruby_llm.openai_organization_id if ruby_llm.openai_organization_id
       c.openai_project_id = ruby_llm.openai_project_id if ruby_llm.openai_project_id
       c.openai_use_system_role = ruby_llm.openai_use_system_role unless ruby_llm.openai_use_system_role.nil?
     end
 
+    # :reek:UncommunicativeParameterName -- `c` is the RubyLLM config being configured; conventional here.
     def apply_default_models(c)
       c.default_model = ruby_llm.default_model if ruby_llm.default_model
       c.default_embedding_model = ruby_llm.default_embedding_model if ruby_llm.default_embedding_model
@@ -124,6 +129,7 @@ module RobotLab
       c.default_moderation_model = ruby_llm.default_moderation_model if ruby_llm.default_moderation_model
     end
 
+    # :reek:UncommunicativeParameterName -- `c` is the RubyLLM config being configured; conventional here.
     def apply_connection_settings(c)
       c.request_timeout = ruby_llm.request_timeout if ruby_llm.request_timeout
       c.max_retries = ruby_llm.max_retries if ruby_llm.max_retries
@@ -133,6 +139,7 @@ module RobotLab
       c.http_proxy = ruby_llm.http_proxy if ruby_llm.http_proxy
     end
 
+    # :reek:UncommunicativeParameterName -- `c` is the RubyLLM config being configured; conventional here.
     def apply_logging_options(c)
       c.log_file = ruby_llm.log_file if ruby_llm.log_file
       c.log_level = ruby_llm.log_level if ruby_llm.log_level
@@ -150,6 +157,7 @@ module RobotLab
 
     # Set a RubyLLM config attribute from config value or standard env var.
     # Only sets when a non-nil value is found, to avoid overwriting defaults.
+    # :reek:UncommunicativeParameterName -- `c` is the RubyLLM config being configured; conventional here.
     def set_if_present(c, setter, config_key, env_var)
       value = ruby_llm.public_send(config_key) || ENV.fetch(env_var, nil)
       c.public_send(:"#{setter}=", value) if value

data/lib/robot_lab/doom_loop_detector.rb

@@ -33,19 +33,21 @@ module RobotLab
       @sequence << tool_name.to_s
     end
 
+    # :reek:TooManyStatements -- self-contained cycle-detection algorithm; splitting the scan loses the shape of the check.
     def doom_loop?
       seq = @sequence
-      return false if seq.length < @threshold
+      length = seq.length
+      return false if length < @threshold
 
       # Consecutive identical calls: A, A, A
       tail = seq.last(@threshold)
       return true if tail.uniq.length == 1
 
       # Cyclic multi-step patterns: A,B,C, A,B,C, A,B,C
-      max_period = [MAX_PERIOD, seq.length / @threshold].min
+      max_period = [MAX_PERIOD, length / @threshold].min
       (2..max_period).each do |period|
         window = @threshold * period
-        next if seq.length < window
+        next if length < window
 
         chunk = seq.last(window)
         pattern = chunk.first(period)
@@ -79,6 +81,7 @@ module RobotLab
 
     private
 
+    # :reek:TooManyStatements -- mirrors doom_loop?'s scan to report which period matched.
     def detect_period(seq)
       return 1 if seq.last(@threshold).uniq.length == 1
 

data/lib/robot_lab/history_compressor.rb

@@ -59,6 +59,7 @@ module RobotLab
     # Execute compression and return the new message array.
     #
     # @return [Array] compressed message array
+    # :reek:TooManyStatements -- linear classify/score/rebuild pipeline; each early return is a documented no-op case.
     def call
       return @messages if @messages.empty?
 
@@ -113,6 +114,7 @@ module RobotLab
     # Determine the action for one compressible message.
     #
     # @return [Symbol, String] :keep, :drop, or a summary String
+    # :reek:TooManyStatements -- one linear score-then-threshold decision.
     def score_action(reference, msg)
       text = extract_text(msg)
 
@@ -133,6 +135,7 @@ module RobotLab
     end
 
     # Build the final message array from the decided actions.
+    # :reek:FeatureEnvy -- dispatching on the per-message action value (:keep/:drop/summary) is this method's purpose.
     def build_result(actions)
       result = []
 
@@ -157,6 +160,7 @@ module RobotLab
     # System messages and tool-related messages are always pinned.
     # Assistant messages with no text content (tool call dispatchers)
     # are also pinned to avoid breaking tool_use/tool_result pairing.
+    # :reek:FeatureEnvy -- classifying by a message's own role and text; Message stays a plain value object.
     def pinned_message?(msg)
       role = msg.role
 
@@ -187,6 +191,7 @@ module RobotLab
     #
     # @param vectors [Array<Hash{Symbol => Float}>]
     # @return [Hash{Symbol => Float}]
+    # :reek:NestedIterators -- 2-deep each over sparse vectors is the natural element-wise sum.
     def mean_vector(vectors)
       return {} if vectors.empty?
 

data/lib/robot_lab/hook.rb

@@ -31,6 +31,7 @@ module RobotLab
   #   robot.on(AuditHook)
   #   network.on(AuditHook)
   #
+  # :reek:InstanceVariableAssumption -- @namespace is a class-level ivar, initialized here and reset in .inherited; there is no #initialize.
   class Hook
     @namespace = nil
 

data/lib/robot_lab/hook_context.rb

@@ -4,9 +4,11 @@ module RobotLab
   class HookContext
     attr_reader :event, :metadata
 
+    # :reek:ControlParameter -- `metadata || ExtensionState.new` is a nil-safe default, not behavior selection.
     def initialize(event:, metadata: nil)
       @event = event.to_sym
       @metadata = metadata || ExtensionState.new
+      @namespace = nil # no hook namespace active until with_namespace
     end
 
     def ext(name)
@@ -46,6 +48,7 @@ module RobotLab
     attr_reader :robot, :network, :task, :memory, :config
     attr_accessor :request, :response, :error
 
+    # :reek:LongParameterList -- one keyword per run-context field; hooks read them all.
     def initialize(robot:, request:, network: nil, task: nil, memory: nil, config: nil, response: nil, error: nil, **)
       super(event: :run, **)
       @robot = robot
@@ -104,6 +107,7 @@ module RobotLab
     attr_reader :network, :task, :task_name, :robot, :memory, :config
     attr_accessor :result, :error
 
+    # :reek:ControlParameter -- `robot || task.robot` is a fallback default, not behavior selection.
     def initialize(task:, network: nil, robot: nil, memory: nil, config: nil, result: nil, error: nil, **)
       super(event: :task, **)
       @network = network

data/lib/robot_lab/hook_registry.rb

@@ -21,6 +21,7 @@ module RobotLab
     # @param handler_class [Class] a RobotLab::Hook subclass
     # @param context [Hash, nil] optional default values merged into ctx.local on each call
     # @return [Registration]
+    # :reek:FeatureEnvy -- validating the handler_class argument before registering it is this method's job.
     def on(handler_class, context: nil)
       unless handler_class.is_a?(Class) && handler_class < RobotLab::Hook
         raise ArgumentError, "#{handler_class.inspect} must be a RobotLab::Hook subclass"

data/lib/robot_lab/hooks.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module RobotLab
+  # :reek:DataClump -- stateless module_function dispatchers; registries/per_run_hooks flow through every call by design.
   module Hooks
     module_function
 
+    # :reek:TooManyStatements -- the before/around/after/error hook lifecycle in one linear sequence.
     def run(family, context, registries:, per_run_hooks: nil, &)
       before = registrations(:"before_#{family}", registries, per_run_hooks)
       around = registrations(:"around_#{family}", registries, per_run_hooks)
@@ -53,9 +55,10 @@ module RobotLab
     end
 
     def call_registration(registration, hook_name, context, &)
-      context.with_namespace(registration.namespace) do
-        if registration.context && registration.namespace
-          context.ext(registration.namespace).merge_defaults(registration.context)
+      namespace = registration.namespace
+      context.with_namespace(namespace) do
+        if registration.context && namespace
+          context.ext(namespace).merge_defaults(registration.context)
         end
         registration.handler_class.call(hook_name, context, &)
       end

data/lib/robot_lab/mcp/client.rb

@@ -13,6 +13,7 @@ module RobotLab
     #   tools = client.list_tools
     #   result = client.call_tool("createBranch", { project_id: "abc" })
     #
+    # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every public operation must check it.
     class Client
       # @!attribute [r] server
       #   @return [Server] the MCP server configuration
@@ -45,6 +46,7 @@ module RobotLab
       #
       # @return [self]
       #
+      # :reek:TooManyStatements -- linear connect/register sequence with a best-effort rescue.
       def connect
         return self if @connected
 
@@ -204,8 +206,6 @@ module RobotLab
       end
 
       def parse_response(response)
-        return response[:result] if response.is_a?(Hash) && response[:result]
-
         case response
         when String
           parsed = JSON.parse(response, symbolize_names: true)

data/lib/robot_lab/mcp/connection_poller.rb

@@ -104,15 +104,20 @@ module RobotLab
       # @param timeout [Numeric] seconds before raising MCPError
       # @return [Hash] parsed response
       # @raise [MCPError] on timeout or connection error
+      # :reek:TooManyStatements -- register/write/wait/cleanup must stay in one method so ensure releases the queue.
+      # :reek:DuplicateMethodCall -- the repeated @mutex.synchronize/@clients[io] pairs are deliberately separate short critical
+      #   sections; holding the lock across the blocking write/wait would deadlock the poll loop.
       def send_request(client, message, timeout:)
-        io      = client.transport.stdout
-        queue   = Thread::Queue.new
+        transport = client.transport
+        io        = transport.stdout
+        stdin     = transport.stdin
+        queue     = Thread::Queue.new
 
         @mutex.synchronize { @clients[io][:queue] = queue }
 
         begin
-          client.transport.stdin.puts(message.to_json)
-          client.transport.stdin.flush
+          stdin.puts(message.to_json)
+          stdin.flush
         rescue Errno::EPIPE, IOError => e
           @mutex.synchronize { @clients[io][:queue] = nil }
           raise MCPError.new("MCP connection lost: #{e.message}", retryable: true)
@@ -160,6 +165,7 @@ module RobotLab
         end
       end
 
+      # :reek:TooManyStatements -- read/parse/filter/route steps for each readable IO; each guard skips a non-response line.
       def dispatch(readable_ios)
         readable_ios.each do |io|
           line = io.gets rescue nil
@@ -177,10 +183,12 @@ module RobotLab
       end
 
       def stdio_client?(client)
-        client.respond_to?(:transport) &&
-          client.transport.is_a?(Transports::Stdio) &&
-          client.transport.respond_to?(:stdout) &&
-          !client.transport.stdout.nil?
+        return false unless client.respond_to?(:transport)
+
+        transport = client.transport
+        transport.is_a?(Transports::Stdio) &&
+          transport.respond_to?(:stdout) &&
+          !transport.stdout.nil?
       end
     end
   end

data/lib/robot_lab/mcp/server_discovery.rb

@@ -60,6 +60,7 @@ module RobotLab
       # @param threshold [Float]           minimum cosine score (default 0.05)
       # @return [Array<Hash, MCP::Server>] matching servers, or +from+ as
       #   fallback when no match is found
+      # :reek:TooManyStatements -- linear guard/score/filter pipeline; each early return is a documented fallback.
       def self.select(query, from:, threshold: DEFAULT_THRESHOLD)
         return from if from.empty?
         return from if query.to_s.strip.empty?

data/lib/robot_lab/mcp/transports/sse.rb

@@ -10,6 +10,8 @@ module RobotLab
       # @example
       #   transport = SSE.new(url: "http://localhost:8080/sse")
       #
+      # :reek:InstanceVariableAssumption -- @config is assigned in Base#initialize (reek does not trace super).
+      # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every operation must check it.
       class SSE < Base
         # Creates a new SSE transport.
         #
@@ -26,6 +28,7 @@ module RobotLab
         #
         # @return [self]
         # @raise [MCPError] if async-http gem is not available
+        # :reek:TooManyStatements -- linear require/connect/handshake sequence inside the Async block.
         def connect
           return self if @connected
 

data/lib/robot_lab/mcp/transports/stdio.rb

@@ -19,6 +19,8 @@ module RobotLab
       #     timeout: 10
       #   )
       #
+      # :reek:InstanceVariableAssumption -- @config and @timeout are assigned in Base#initialize (reek does not trace super).
+      # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every IO operation must check it.
       class Stdio < Base
         # Creates a new Stdio transport.
         #
@@ -41,6 +43,7 @@ module RobotLab
         # @return [self]
         # @raise [MCPError] if the server process cannot be started or does not
         #   respond to the MCP initialize handshake within the timeout period
+        # :reek:TooManyStatements -- linear spawn/verify/handshake sequence with per-failure-mode rescues.
         def connect
           return self if @connected
 
@@ -76,6 +79,7 @@ module RobotLab
         # @param message [Hash] JSON-RPC message
         # @return [Hash] the response
         # @raise [MCPError] if not connected, no response, or timeout
+        # :reek:TooManyStatements -- write-then-read loop must stay inside the one Timeout block.
         def send_request(message)
           raise MCPError, "Not connected" unless @connected
 
@@ -148,6 +152,7 @@ module RobotLab
           @stdin.flush
         end
 
+        # :reek:TooManyStatements -- best-effort teardown; each handle is closed and nilled independently.
         def cleanup_process
           @connected = false
           @stdin&.close  rescue nil

data/lib/robot_lab/mcp/transports/streamable_http.rb

@@ -13,6 +13,8 @@ module RobotLab
       #     session_id: "abc123"
       #   )
       #
+      # :reek:InstanceVariableAssumption -- @config is assigned in Base#initialize (reek does not trace super).
+      # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every operation must check it.
       class StreamableHTTP < Base
         # Creates a new StreamableHTTP transport.
         #
@@ -31,6 +33,7 @@ module RobotLab
         #
         # @return [self]
         # @raise [MCPError] if async-http gem is not available
+        # :reek:TooManyStatements -- linear require/connect/handshake sequence inside the Async block.
         def connect
           return self if @connected
 
@@ -60,6 +63,7 @@ module RobotLab
         # @param message [Hash] JSON-RPC message
         # @return [Hash] the response
         # @raise [MCPError] if not connected
+        # :reek:TooManyStatements -- header assembly and POST must stay inside the one Async block.
         def send_request(message)
           raise MCPError, "Not connected" unless @connected
 

data/lib/robot_lab/mcp/transports/websocket.rb

@@ -10,6 +10,8 @@ module RobotLab
       # @example
       #   transport = WebSocket.new(url: "ws://localhost:8080")
       #
+      # :reek:InstanceVariableAssumption -- @config is assigned in Base#initialize (reek does not trace super).
+      # :reek:RepeatedConditional -- @connected is the connection-lifecycle guard; every operation must check it.
       class WebSocket < Base
         # Creates a new WebSocket transport.
         #
@@ -26,6 +28,7 @@ module RobotLab
         #
         # @return [self]
         # @raise [MCPError] if async-websocket gem is not available
+        # :reek:TooManyStatements -- linear require/connect/handshake sequence inside the Async block.
         def connect
           return self if @connected