robot_lab-to 0.2.7 → 0.2.8

data/lib/robot_lab/to/exit_summary.rb

@@ -11,14 +11,9 @@ module RobotLab
       end
 
       def print
-        stat       = @run.base_commit ? diff_stat : { insertions: 0, deletions: 0, files: 0 }
-        aborted    = !@abort_reason.nil?
-        good_iters = @run.commits
-        fail_iters = @run.iteration - good_iters
-
         puts ""
-        print_header(aborted)
-        print_counters(good_iters, fail_iters, stat)
+        @abort_reason ? print_aborted_header : print_completed_header
+        print_counters
         print_paths
         print_next_steps
         puts ""
@@ -26,17 +21,21 @@ module RobotLab
 
       private
 
-      def print_header(aborted)
-        if aborted
-          puts "robot-to stopped — #{@config.model} — #{@run.elapsed_human}"
-          puts "Reason: #{@abort_reason}"
-        else
-          puts "robot-to complete — #{@config.model} — #{@run.elapsed_human}"
-          puts "Branch: #{@run.branch}"
-        end
+      def print_aborted_header
+        puts "robot-to stopped — #{@config.model} — #{@run.elapsed_human}"
+        puts "Reason: #{@abort_reason}"
+      end
+
+      def print_completed_header
+        puts "robot-to complete — #{@config.model} — #{@run.elapsed_human}"
+        puts "Branch: #{@run.branch}"
       end
 
-      def print_counters(good_iters, fail_iters, stat)
+      def print_counters
+        good_iters = @run.commits
+        fail_iters = @run.iteration - good_iters
+        stat       = diff_stat
+
         puts ""
         puts "Iterations:      #{@run.iteration} total  (#{good_iters} good / #{fail_iters} failed)"
         puts "Tokens:          #{comma(@run.total_tokens)}  (#{comma(@run.input_tokens)} in / #{comma(@run.output_tokens)} out)"
@@ -61,6 +60,8 @@ module RobotLab
       end
 
       def diff_stat
+        return { insertions: 0, deletions: 0, files: 0 } unless @run.base_commit
+
         git = CommitManager.new
         git.diff_stat(@run.base_commit)
       rescue StandardError

data/lib/robot_lab/to/guards/checkpoint.rb

@@ -48,7 +48,12 @@ module RobotLab
 
             tracked << path
             FileUtils.mkdir_p(dir)
-            dest = File.join(dir, safe_name(path))
+            write_backup(path, File.join(dir, safe_name(path)))
+          rescue SystemCallError, IOError
+            nil
+          end
+
+          def write_backup(path, dest)
             if File.exist?(path)
               FileUtils.cp(path, dest)
               dest
@@ -56,8 +61,6 @@ module RobotLab
               File.write("#{dest}.absent", "")
               "#{dest}.absent"
             end
-          rescue SystemCallError, IOError
-            nil
           end
 
           # @return [String] directory for this run's checkpoints (created)

data/lib/robot_lab/to/guards/quality_monitor.rb

@@ -73,8 +73,9 @@ module RobotLab
             return :empty_response if text.to_s.strip.empty? && calls.empty?
 
             calls.each do |c|
-              return :empty_tool_name if c[:name].to_s.empty?
-              return "unknown_tool:#{c[:name]}" if known.any? && !known.include?(c[:name])
+              name = c[:name]
+              return :empty_tool_name if name.to_s.empty?
+              return "unknown_tool:#{name}" if known.any? && !known.include?(name)
             end
 
             return :repeated_tool_call if repeated?(calls, previous)
@@ -83,6 +84,7 @@ module RobotLab
           end
 
           # True when any current call exactly matches any previous call.
+          # :reek:NestedIterators -- an all-pairs comparison needs both loops.
           def repeated?(calls, previous)
             return false if calls.empty? || previous.empty?
 

data/lib/robot_lab/to/guards/run_store.rb

@@ -22,8 +22,10 @@ module RobotLab
 
         # Fetch the value for `key`, initializing to `default` when unset.
         def fetch(key, default = nil)
-          Thread.current[key] = default if Thread.current[key].nil? && !default.nil?
-          Thread.current[key]
+          value = Thread.current[key]
+          return value unless value.nil?
+
+          Thread.current[key] = default
         end
       end
     end

data/lib/robot_lab/to/notes_manager.rb

@@ -13,6 +13,7 @@ module RobotLab
         @path = Pathname.new(path)
       end
 
+      # :reek:FeatureEnvy -- interpolating the run's own fields into the header.
       def setup(run)
         AtomicFile.write(@path, <<~HEADER)
           # robot-to run: #{run.run_id}
@@ -84,6 +85,7 @@ module RobotLab
         MD
       end
 
+      # :reek:FeatureEnvy -- interpolating the error's own class/message.
       def append_error(error, iteration)
         append(<<~MD)
 
@@ -93,6 +95,7 @@ module RobotLab
         MD
       end
 
+      # :reek:FeatureEnvy -- interpolating the decision's own fields.
       def append_decision(decision, iteration)
         append(<<~MD)
 

data/lib/robot_lab/to/orchestrator.rb

@@ -14,6 +14,17 @@ module RobotLab
     # not make alone, it is written to a decision file (see DecisionManager). A
     # blocking decision either pauses the loop (decision_mode: wait) or stops the
     # run for a later `--resume` (decision_mode: exit).
+    #
+    # :reek:TooManyMethods :reek:TooManyInstanceVariables -- this is the
+    # single object that owns the whole iteration lifecycle (setup, agent
+    # turn, eval gate, commit/rollback, decisions, tokens, signals). Splitting
+    # it apart would scatter state (@run, @git, @pending_commit_failure,
+    # @stop_requested, ...) across collaborators that would just pass it back
+    # and forth -- see the "Architecture" section of CLAUDE.md.
+    # :reek:RepeatedConditional -- @stop_requested, @pending_commit_failure,
+    # and decisions_enabled? are real orchestrator-wide state, legitimately
+    # checked at each point that must react to it; that is what a run loop's
+    # flags are for, not a sign the checks belong on another object.
     class Orchestrator
       SIGNAL_STOP = "graceful_stop"
 
@@ -43,10 +54,17 @@ module RobotLab
         @decisions              = nil
         @decision_tool          = nil
         @injected_decisions     = []
+        @backoff                = nil
+        @builder                = nil
+        @notes                  = nil
+        @stop_conditions        = nil
         @accounted_in           = 0
         @accounted_out          = 0
       end
 
+      # :reek:TooManyStatements -- top-level run/rescue/ensure sequence for the
+      # whole process; the rescue branches are already split into their own
+      # error-shaped clauses.
       def run
         @resume_run_id ? setup_resume : setup_run
         install_signal_handlers
@@ -64,15 +82,18 @@ module RobotLab
         @git&.reset_hard unless @pending_commit_failure
         @logger.log("orchestrator:abort", reason: @abort_reason, permanent: true)
       rescue => e
-        @abort_reason = "fatal: #{e.message}"
+        message = e.message
+        @abort_reason = "fatal: #{message}"
         @git&.reset_hard unless @pending_commit_failure
-        @logger.log("orchestrator:fatal", error: e.class.to_s, message: e.message)
+        @logger.log("orchestrator:fatal", error: e.class.to_s, message: message)
       ensure
         finalize_run
       end
 
       private
 
+      # :reek:TooManyStatements -- the loop body is the iteration lifecycle in
+      # its literal execution order; splitting it further would hide that order.
       def main_loop
         loop do
           break if @stop_requested
@@ -83,8 +104,9 @@ module RobotLab
           @stop_conditions.before?
 
           @run.iteration += 1
-          @logger.log("iteration:start", iteration: @run.iteration)
-          progress "iteration #{@run.iteration} (#{@config.model})..."
+          iteration = @run.iteration
+          @logger.log("iteration:start", iteration: iteration)
+          progress "iteration #{iteration} (#{@config.model})..."
 
           result = execute_iteration
 
@@ -114,6 +136,8 @@ module RobotLab
         end
       end
 
+      # :reek:TooManyStatements -- one-time run bootstrap, each step required
+      # in this order (branch, run dir, Run record, logger, notes, collaborators).
       def setup_run
         @git = CommitManager.new
         ensure_head!
@@ -143,6 +167,8 @@ module RobotLab
 
       # Resume a prior run from its run.json — enables external scheduling (cron):
       # each tick re-enters the loop on the same branch and advances or re-pauses.
+      # :reek:TooManyStatements -- mirrors #setup_run's bootstrap order for the
+      # resume path.
       def setup_resume
         @git = CommitManager.new
         ensure_head!
@@ -152,7 +178,8 @@ module RobotLab
 
         @run       = Run.load(state_path)
         @objective = @run.objective
-        @git.checkout_branch(@run.branch)
+        branch     = @run.branch
+        @git.checkout_branch(branch)
 
         @logger.open(@run.log_path)
         @notes = NotesManager.new(@run.notes_path)  # append — do NOT re-setup (would clobber history)
@@ -160,8 +187,8 @@ module RobotLab
         build_collaborators
 
         @logger.log("orchestrator:resume", run_id: @run.run_id, iteration: @run.iteration,
-                                           branch: @run.branch, model: @config.model)
-        progress "resumed run #{@run.run_id} at iteration #{@run.iteration} → branch #{@run.branch}"
+                                           branch: branch, model: @config.model)
+        progress "resumed run #{@run.run_id} at iteration #{@run.iteration} → branch #{branch}"
       end
 
       # Shared setup used by both a fresh run and a resume.
@@ -202,11 +229,14 @@ module RobotLab
 
       # Poll the decision files until every blocking decision is resolved, the run
       # is signaled to stop, or decision_timeout elapses.
+      # :reek:TooManyStatements -- the three exit conditions (stopped, resolved,
+      # timed out) must all be checked inside one poll loop.
       def wait_for_decisions(pending)
         progress "awaiting human decision on #{pending.size} item(s):"
         pending.each { |d| progress "  #{d.path}" }
         @logger.log("decision:wait:start", count: pending.size)
-        deadline = @config.decision_timeout ? monotonic + @config.decision_timeout.to_i : nil
+        timeout  = @config.decision_timeout
+        deadline = timeout ? monotonic + timeout.to_i : nil
 
         loop do
           return if @stop_requested
@@ -216,7 +246,7 @@ module RobotLab
           break unless @decisions.blocking_pending?
 
           if deadline && monotonic >= deadline
-            raise AbortError, "awaiting human decision (timed out after #{@config.decision_timeout}s)"
+            raise AbortError, "awaiting human decision (timed out after #{timeout}s)"
           end
         end
 
@@ -238,6 +268,8 @@ module RobotLab
 
       # The happy path: build a fresh robot, run it, and return its submitted
       # result (or a not-submitted marker).
+      # :reek:TooManyStatements -- one call per lifecycle step (reset counters,
+      # build prompt/robot, run, nudge, persist decisions, return result).
       def run_agent_iteration
         @accounted_in = @accounted_out = 0
         @submit_tool   = Tools::SubmitResult.new
@@ -265,12 +297,13 @@ module RobotLab
       def persist_raised_decisions
         return unless @decision_tool
 
+        iteration = @run.iteration
         @decision_tool.captured_requests.each do |req|
-          decision = @decisions.record(**req, iteration: @run.iteration)
-          @notes.append_decision(decision, @run.iteration)
+          decision = @decisions.record(**req, iteration: iteration)
+          @notes.append_decision(decision, iteration)
           @logger.log("decision:raised", id: decision.id, blocking: decision.blocking,
                                           question: decision.question)
-          progress "iteration #{@run.iteration} raised decision: #{decision.question}"
+          progress "iteration #{iteration} raised decision: #{decision.question}"
         end
       end
 
@@ -298,10 +331,11 @@ module RobotLab
       # True when the iteration should be retried — within the retry budget and
       # not stopping. Sleeps out the backoff as a side effect before returning.
       def retry_after_backoff?
-        return false unless @run.consecutive_errors <= @config.max_retries && !@stop_requested
+        errors = @run.consecutive_errors
+        return false unless errors <= @config.max_retries && !@stop_requested
 
-        @logger.log("backoff:start", consecutive_errors: @run.consecutive_errors)
-        @backoff.sleep_for(@run.consecutive_errors)
+        @logger.log("backoff:start", consecutive_errors: errors)
+        @backoff.sleep_for(errors)
         @logger.log("backoff:end")
         true
       end
@@ -367,8 +401,9 @@ module RobotLab
 
       def handle_no_improvement(result, score)
         iteration = @run.iteration
+        detail    = score.detail
         @git.reset_hard unless @pending_commit_failure
-        @notes.append_no_improvement(result, score.detail, iteration)
+        @notes.append_no_improvement(result, detail, iteration)
         # A non-improving iteration is valid work that just wasn't better -- NOT a
         # failure. It counts toward the plateau (diminishing-returns) stop only, so
         # it must NOT trip max_consecutive_failures, which is for the robot being
@@ -377,8 +412,8 @@ module RobotLab
         # verdicts are common and normal.
         @run.iterations_since_improvement += 1
         @run.consecutive_errors = 0
-        @logger.log("iteration:no_improvement", iteration: iteration, detail: score.detail)
-        progress "iteration #{iteration} no improvement (#{score.detail}) — rolled back"
+        @logger.log("iteration:no_improvement", iteration: iteration, detail: detail)
+        progress "iteration #{iteration} no improvement (#{detail}) — rolled back"
       end
 
       # A resolved decision that was injected into this successful iteration has
@@ -405,14 +440,16 @@ module RobotLab
         score
       end
 
+      # :reek:TooManyStatements -- rollback + record + report, one statement each.
       def handle_gate_failure(result, score)
+        iteration = @run.iteration
         @git.reset_hard unless @pending_commit_failure
-        @notes.append_verify_failure(result, score.output.to_s, @run.iteration)
+        @notes.append_verify_failure(result, score.output.to_s, iteration)
         @run.consecutive_failures += 1
         @run.consecutive_errors    = 0
         @run.iterations_since_improvement += 1
-        @logger.log("iteration:gate_failure", iteration: @run.iteration)
-        progress "iteration #{@run.iteration} verification failed — rolled back"
+        @logger.log("iteration:gate_failure", iteration: iteration)
+        progress "iteration #{iteration} verification failed — rolled back"
         nil
       end
 
@@ -421,19 +458,22 @@ module RobotLab
       # the code, re-verifying after each attempt. Only fall back to a full
       # rollback once the repair budget is spent — a near-miss no longer discards
       # all the work, and nothing commits until the gate is green.
+      # :reek:TooManyStatements -- repair/re-verify loop with its own rescue;
+      # each statement is a distinct step of one repair attempt.
       def repair_until_gate(result, score)
-        budget = @config.max_verify_repairs.to_i
+        budget    = @config.max_verify_repairs.to_i
+        iteration = @run.iteration
         return [result, score] if budget.zero? || @robot.nil?
 
         budget.times do |i|
           break if @stop_requested
 
-          @logger.log("eval:repair", iteration: @run.iteration, attempt: i + 1)
-          progress "iteration #{@run.iteration}: verification failed — repairing (#{i + 1}/#{budget})"
+          @logger.log("eval:repair", iteration: iteration, attempt: i + 1)
+          progress "iteration #{iteration}: verification failed — repairing (#{i + 1}/#{budget})"
           begin
             run_robot_with_interrupt(@robot, repair_prompt(score))
           rescue StandardError => e
-            @logger.log("eval:repair_error", iteration: @run.iteration, message: e.message)
+            @logger.log("eval:repair_error", iteration: iteration, message: e.message)
             break
           end
           result = @submit_tool.captured_result || result
@@ -459,16 +499,20 @@ module RobotLab
       end
 
       def handle_failure(result)
+        iteration = @run.iteration
         @git.reset_hard unless @pending_commit_failure
-        @notes.append_failure(result, @run.iteration)
+        @notes.append_failure(result, iteration)
         @run.consecutive_failures += 1
         @run.consecutive_errors = 0
         @run.iterations_since_improvement += 1
-        @logger.log("iteration:failure", iteration: @run.iteration, summary: result.summary)
-        progress "iteration #{@run.iteration} failed: #{result.summary}"
+        @logger.log("iteration:failure", iteration: iteration, summary: result.summary)
+        progress "iteration #{iteration} failed: #{result.summary}"
       end
 
+      # :reek:TooManyStatements -- commit path plus its own CommitFailedError
+      # rescue; the two branches (success, queue-for-repair) are each tight.
       def attempt_commit(result)
+        iteration = @run.iteration
         @git.add_all
         return unless @git.staged?
 
@@ -476,16 +520,17 @@ module RobotLab
         @git.commit(message)
         @run.commits += 1
         @pending_commit_failure = nil
-        @logger.log("commit:success", iteration: @run.iteration, message: message)
-        progress "iteration #{@run.iteration} committed: #{message}"
+        @logger.log("commit:success", iteration: iteration, message: message)
+        progress "iteration #{iteration} committed: #{message}"
       rescue CommitFailedError => e
         @pending_commit_failure = e
         @run.consecutive_failures += 1
         @run.consecutive_errors = 0
-        @logger.log("commit:failed", iteration: @run.iteration, output: e.output)
-        progress "iteration #{@run.iteration} commit failed — queued for repair"
+        @logger.log("commit:failed", iteration: iteration, output: e.output)
+        progress "iteration #{iteration} commit failed — queued for repair"
       end
 
+      # :reek:FeatureEnvy -- formatting the commit message from result's own fields.
       def commit_message(result)
         if @config.commit_format == "conventional"
           type  = result.respond_to?(:type)  ? (result.type || "chore") : "chore"
@@ -565,6 +610,8 @@ module RobotLab
         end
       end
 
+      # :reek:TooManyStatements -- runs the robot on its own Thread so a signal
+      # can interrupt it; each statement manages that thread's lifecycle.
       def run_robot_with_interrupt(robot, task = @objective)
         thread_error = nil
         result = nil

data/lib/robot_lab/to/prompt_builder.rb

@@ -8,6 +8,8 @@ module RobotLab
         @config = config
       end
 
+      # :reek:TooManyStatements -- each line is one optional prompt section, in
+      # the exact order they appear; a data-table would hide that ordering.
       def build(run, notes_content, workspace: nil, pending_commit_failure: nil, resolved_decisions: [])
         sections = [role_section(run), notes_section(run, notes_content)]
         sections << workspace_section(workspace) if workspace && !workspace.empty?

data/lib/robot_lab/to/run.rb

@@ -13,6 +13,8 @@ module RobotLab
                     :commits, :input_tokens, :output_tokens,
                     :last_score_value, :iterations_since_improvement
 
+      # :reek:ControlParameter -- run_dir/decisions_path fall back to a sibling
+      # path when omitted; that's a constructor default, not a behavior branch.
       def initialize(run_id:, objective:, branch:, base_commit:, notes_path:, log_path:,
                      run_dir: nil, decisions_path: nil)
         @run_id              = run_id
@@ -38,6 +40,7 @@ module RobotLab
       def elapsed_seconds  = Time.now - started_at
       def state_path       = @run_dir.join("run.json")
 
+      # :reek:FeatureEnvy -- decomposing our own elapsed_seconds into h/m/s.
       def elapsed_human
         secs = elapsed_seconds.to_i
         h = secs / 3600
@@ -71,14 +74,11 @@ module RobotLab
                    base_commit: data[:base_commit], notes_path: data[:notes_path],
                    log_path: data[:log_path], run_dir: data[:run_dir],
                    decisions_path: data[:decisions_path])
-        run.iteration            = data[:iteration].to_i
-        run.consecutive_failures = data[:consecutive_failures].to_i
-        run.consecutive_errors   = data[:consecutive_errors].to_i
-        run.commits              = data[:commits].to_i
-        run.input_tokens         = data[:input_tokens].to_i
-        run.output_tokens        = data[:output_tokens].to_i
-        run.last_score_value     = data[:last_score_value]
-        run.iterations_since_improvement = data[:iterations_since_improvement].to_i
+        %i[iteration consecutive_failures consecutive_errors commits input_tokens
+           output_tokens iterations_since_improvement].each do |key|
+          run.public_send(:"#{key}=", data[key].to_i)
+        end
+        run.last_score_value = data[:last_score_value]
         run.instance_variable_set(:@started_at, Time.parse(data[:started_at])) if data[:started_at]
         run
       end

data/lib/robot_lab/to/stop_conditions.rb

@@ -3,6 +3,8 @@
 module RobotLab
   module To
     # Evaluates all stop conditions against the current run state.
+    # :reek:RepeatedConditional -- each `limit` is an unrelated config value
+    # (max_iterations/max_tokens/stop_on_plateau) nil-guarded in its own check.
     class StopConditions
       def initialize(config, run)
         @config = config
@@ -38,17 +40,19 @@ module RobotLab
       private
 
       def check_max_iterations
-        return unless @config.max_iterations
-        return unless @run.iteration >= @config.max_iterations
+        limit = @config.max_iterations
+        return unless limit
+        return unless @run.iteration >= limit
 
-        raise AbortError, "max iterations reached (#{@config.max_iterations})"
+        raise AbortError, "max iterations reached (#{limit})"
       end
 
       def check_max_tokens
-        return unless @config.max_tokens
-        return unless @run.total_tokens >= @config.max_tokens
+        limit = @config.max_tokens
+        return unless limit
+        return unless @run.total_tokens >= limit
 
-        raise AbortError, "max tokens reached (#{@config.max_tokens})"
+        raise AbortError, "max tokens reached (#{limit})"
       end
 
       def check_consecutive_failures

data/lib/robot_lab/to/tools/bash.rb

@@ -25,6 +25,8 @@ module RobotLab
           @default_timeout = timeout
         end
 
+        # :reek:ControlParameter -- falling back to the instance default when
+        # the LLM omits the optional `timeout` argument.
         def execute(command:, timeout: nil, **)
           out, status = run(command, (timeout || @default_timeout).to_i)
           format_result(out, status)
@@ -34,6 +36,9 @@ module RobotLab
         # status_string is "0".."n" for an exit code, or "timeout"/"error: ...".
         #
         # @return [Array(String, String)]
+        # :reek:TooManyStatements :reek:NestedIterators -- spawn, read
+        # concurrently, wait-or-kill, join: each step is one statement and the
+        # streaming reader inherently nests a loop inside its own Thread.
         def run(command, timeout)
           out_str = +""
           status = nil

data/lib/robot_lab/to/tools/edit.rb

@@ -19,6 +19,11 @@ module RobotLab
         param :new_text, type: "string", desc: "Replacement text"
         param :replace_all, type: "boolean", desc: "Replace every occurrence", required: false
 
+        # :reek:BooleanParameter -- replace_all is a tool param the LLM sets;
+        # the `param` declarations above fix this signature.
+        # :reek:FeatureEnvy -- inspecting #apply's own return value.
+        # :reek:TooManyStatements -- validate, transform, write, report; each
+        # step is one statement in a tool #execute contract method.
         def execute(path:, old_text:, new_text:, replace_all: false, **)
           resolved = File.expand_path(path, Dir.pwd)
           return "Error: file not found: #{path}" unless File.file?(resolved)

data/lib/robot_lab/to/tools/request_decision.rb

@@ -44,6 +44,10 @@ module RobotLab
           @captured_requests ||= []
         end
 
+        # :reek:BooleanParameter :reek:ControlParameter -- blocking is both
+        # stored data and legitimately changes the guidance message returned
+        # to the robot; the `param` declarations above fix this signature.
+        # :reek:LongParameterList -- one field per tool param declared above.
         def execute(question:, situation: "", options: [], recommendation: "", blocking: false, **)
           (@captured_requests ||= []) << {
             question: question,

data/lib/robot_lab/to/tools/submit_result.rb

@@ -34,6 +34,7 @@ module RobotLab
 
         attr_reader :captured_result
 
+        # :reek:LongParameterList -- one field per tool param declared above.
         def execute(success:, summary:, key_changes: [], key_learnings: [], should_fully_stop: nil, **)
           @captured_result = IterationResult.new(
             success: success,

data/lib/robot_lab/to/version.rb

@@ -2,6 +2,6 @@
 
 module RobotLab
   module To
-    VERSION = "0.2.7"
+    VERSION = "0.2.8"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: robot_lab-to
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -57,6 +57,7 @@ files:
 - ".loki"
 - ".quality/reek_baseline.txt"
 - ".rubocop.yml"
+- Archspec.rb
 - CHANGELOG.md
 - CLAUDE.md
 - COMMITS.md
@@ -85,6 +86,7 @@ files:
 - docs/local-models/ollama.md
 - docs/local-models/tools.md
 - docs/reference/architecture.md
+- examples/.envrc
 - examples/01_basic_usage/.gitignore
 - examples/01_basic_usage/README.md
 - examples/01_basic_usage/basic_usage.rb
@@ -104,6 +106,7 @@ files:
 - examples/04_prose/prompts_dir/section_criteria.md
 - examples/04_prose/prompts_dir/sections_objective.md
 - examples/04_prose/prose_run.rb
+- examples/common.rb
 - lib/robot_lab/to.rb
 - lib/robot_lab/to/atomic_file.rb
 - lib/robot_lab/to/backoff.rb
@@ -169,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.19
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Autonomous overnight agent loop for RobotLab — run robots while you sleep.
 test_files: []