robot_lab 0.0.4 → 0.0.7

data/examples/14_rusty_circuit/heckler.rb

@@ -11,6 +11,8 @@
 # own jokes using the comedian as the punch line.
 #
 # Subscribes to the :room channel to hear performances.
+# Room deliveries are routed through the core processing guard,
+# which serializes run() calls to prevent Async fiber interleaving.
 # Sends feedback directly to the comic's personal channel.
 #
 class Heckler < RobotLab::Robot
@@ -23,10 +25,10 @@ class Heckler < RobotLab::Robot
 
     super(name: "heckler", template: :open_mic_heckler, bus: bus)
 
-    # Listen to the room for the comic's performances
-    @bus.subscribe(:room) do |delivery|
-      delivery.ack!
-      message = delivery.message
+    # Handle incoming messages — the core processing guard
+    # serializes all deliveries, preventing concurrent run()
+    # calls from corrupting chat history.
+    on_message do |message|
       next unless message.from == "comic"
       next if @rounds >= MAX_ROUNDS
 
@@ -39,9 +41,7 @@ class Heckler < RobotLab::Robot
       ).reply.strip
 
       # The heckler chose silence — no output, no feedback
-      if verdict.match?(/\[SILENCE\]/i)
-        next
-      end
+      next if verdict.match?(/\[SILENCE\]/i)
 
       @display.heckler("Heckler [Round #{@rounds}]", verdict)
 
@@ -51,7 +51,13 @@ class Heckler < RobotLab::Robot
       end
 
       # Send feedback to comic's personal channel until the set is done
-      reply(message, verdict) if @rounds < MAX_ROUNDS
+      send_reply(to: message.from.to_sym, content: verdict, in_reply_to: message.key) if @rounds < MAX_ROUNDS
+    end
+
+    # Listen to the room for the comic's performances.
+    # Route through the core processing guard.
+    @bus.subscribe(:room) do |delivery|
+      handle_incoming_delivery(delivery)
     end
   end
 end

data/examples/14_rusty_circuit/open_mic.rb

@@ -23,8 +23,10 @@
 # Communication uses a shared :room channel — the comic publishes
 # performances there, and both the heckler and scout subscribe.
 # The heckler sends feedback directly to the comic's personal channel.
-# The scout uses a processing guard to serialize observations,
-# preventing Async fiber interleaving from corrupting chat history.
+# Room deliveries are routed through the core processing guard
+# (BusMessaging#handle_incoming_delivery), which serializes all
+# run() calls to prevent Async fiber interleaving from corrupting
+# chat history.
 #
 # Style reinventions are injected into the next round's user prompt
 # rather than modifying the chat's system messages, avoiding message
@@ -96,7 +98,7 @@ display.comic("Comic [Opening]", opening)
 # channel, triggering the feedback loop:
 #   room → heckler → comic → room → heckler → comic → ...
 # The loop terminates when the heckler stops replying (MAX_ROUNDS).
-# The scout observes each round via :room with serialized processing.
+# The scout observes each round via :room, serialized by the core guard.
 comic.send_message(to: :room, content: "OPENING: #{opening}")
 
 display.separator

data/examples/14_rusty_circuit/scout.rb

@@ -69,10 +69,10 @@ end
 # analysts when they see something worth examining closely.
 #
 # Subscribes to the :room channel to observe performances.
-# Uses a processing guard to serialize run() calls — TypedBus
-# delivers messages in concurrent Async fibers, and interleaved
-# run() calls on the same @chat would corrupt tool_use/tool_result
-# ordering in the Anthropic API.
+# Room deliveries are routed through the core processing guard
+# (BusMessaging#handle_incoming_delivery), which serializes all
+# run() calls to prevent Async fiber interleaving from corrupting
+# chat history.
 #
 class Scout < RobotLab::Robot
   attr_accessor :log, :analysts_spawned, :pending_criteria, :display
@@ -81,8 +81,6 @@ class Scout < RobotLab::Robot
     @log = []
     @analysts_spawned = 0
     @pending_criteria = nil
-    @processing = false
-    @observation_queue = []
     @display = display
 
     super(
@@ -95,20 +93,18 @@ class Scout < RobotLab::Robot
       ]
     )
 
-    # Listen to the room for the comic's performances.
-    # Processing guard prevents concurrent run() calls on @chat —
-    # observations that arrive while processing are queued and
-    # drained sequentially after the current one completes.
-    @bus.subscribe(:room) do |delivery|
-      delivery.ack!
-      message = delivery.message
+    # Handle incoming messages — the core processing guard
+    # serializes all deliveries, preventing concurrent run()
+    # calls from corrupting chat history.
+    on_message do |message|
       next unless message.from == "comic"
+      observe_and_note(message.content.to_s)
+    end
 
-      if @processing
-        @observation_queue << message.content.to_s
-      else
-        process_observation(message.content.to_s)
-      end
+    # Listen to the room for the comic's performances.
+    # Route through the core processing guard.
+    @bus.subscribe(:room) do |delivery|
+      handle_incoming_delivery(delivery)
     end
   end
 
@@ -133,19 +129,6 @@ class Scout < RobotLab::Robot
 
   private
 
-  def process_observation(content)
-    @processing = true
-
-    observe_and_note(content)
-
-    # Drain any observations that arrived while we were processing
-    while (queued = @observation_queue.shift)
-      observe_and_note(queued)
-    end
-
-    @processing = false
-  end
-
   def observe_and_note(content)
     @log << content
 

data/examples/15_memory_network_and_bus/editorial_pipeline.rb

@@ -109,7 +109,7 @@ editor.on_message do |message|
   puts "  Editor  [revised]: #{revised[0..120]}..."
   puts "  [editor] Revision written to #{path}"
 
-  editor.reply(message, revised)
+  editor.send_reply(to: message.from.to_sym, content: revised, in_reply_to: message.key)
 end
 
 chief = EditorInChief.new(

data/examples/16_writers_room/display.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "rainbow"
+require "io/console"
+
+# ── Display ─────────────────────────────────────────────────
+#
+# Terminal formatting for the Writers' Room demo.
+#
+#   - Broadcasts: white, prefixed with speaker name
+#   - Direct messages: magenta, shows sender → recipient
+#   - Memory writes: dimmed annotation
+#   - Spawns: green annotation
+#   - Completion: bright green
+#   - Chapter content: cyan (when assembled)
+#
+class Display
+  WRITER_COLORS = %i[cyan yellow blue magenta white].freeze
+
+  def initialize(log_path: nil)
+    @term_width = (IO.console&.winsize&.last || 80)
+    @wrap_width = @term_width - 8
+    @log_file = log_path ? File.open(log_path, "w") : nil
+    @color_map = {}
+    @next_color = 0
+  end
+
+  # ── Room Messages ──────────────────────────────────────────
+
+  def broadcast(from, text)
+    color = color_for(from)
+    puts
+    puts Rainbow("  [#{from}] (broadcast):").send(color).bright
+    wrap(text, @wrap_width).each do |line|
+      puts Rainbow("    #{line}").send(color)
+    end
+
+    log("\n  [#{from}] (broadcast):")
+    wrap(text, @wrap_width).each { |line| log("    #{line}") }
+  end
+
+  def direct_message(from, to, text)
+    puts Rainbow("    [#{from} -> #{to}]: #{text[0..100]}").magenta.faint
+    log("    [#{from} -> #{to}]: #{text[0..100]}")
+  end
+
+  # ── Memory ─────────────────────────────────────────────────
+
+  def memory_write(writer, key)
+    puts Rainbow("    [memory] #{writer} wrote :#{key}").darkgray
+    log("    [memory] #{writer} wrote :#{key}")
+  end
+
+  # ── Lifecycle ──────────────────────────────────────────────
+
+  def spawn(requester, name)
+    puts Rainbow("    [spawn] #{requester} recruited #{name}").green
+    log("    [spawn] #{requester} recruited #{name}")
+  end
+
+  def complete(writer)
+    puts
+    puts Rainbow("  [#{writer}] marked the work as COMPLETE").green.bright
+    log("\n  [#{writer}] marked the work as COMPLETE")
+  end
+
+  # ── Incoming message (from bus, before LLM processes) ──────
+
+  def incoming(writer, from, content)
+    puts Rainbow("    [#{writer}] heard #{from}: #{content.to_s[0..80]}...").darkgray
+    log("    [#{writer}] heard #{from}: #{content.to_s[0..80]}...")
+  end
+
+  # ── Chrome ─────────────────────────────────────────────────
+
+  def banner(text)
+    puts
+    text.each_line { |line| puts Rainbow(line.chomp).bright }
+    puts
+
+    log("")
+    text.each_line { |line| log(line.chomp) }
+  end
+
+  def separator
+    puts Rainbow("  #{"─" * (@term_width - 4)}").darkgray
+    puts
+    log("  #{"─" * 56}")
+    log("")
+  end
+
+  def phase(text)
+    puts
+    puts Rainbow("  ▸ #{text}").bright
+    puts
+    log("\n  ▸ #{text}\n")
+  end
+
+  def info(text)
+    puts Rainbow("  #{text}").darkgray
+    log("  #{text}")
+  end
+
+  def stats(text)
+    puts
+    text.each_line { |line| puts Rainbow(line.chomp).bright }
+    log("")
+    text.each_line { |line| log(line.chomp) }
+  end
+
+  def close
+    @log_file&.close
+  end
+
+  private
+
+  def color_for(name)
+    @color_map[name] ||= begin
+      c = WRITER_COLORS[@next_color % WRITER_COLORS.size]
+      @next_color += 1
+      c
+    end
+  end
+
+  def log(line)
+    return unless @log_file
+
+    @log_file.puts line
+    @log_file.flush
+  end
+
+  def wrap(text, max_width)
+    lines = []
+
+    text.to_s.each_line do |paragraph|
+      paragraph = paragraph.strip
+      next(lines << "") if paragraph.empty?
+
+      words = paragraph.split(/\s+/)
+      current = +""
+
+      words.each do |word|
+        if current.empty?
+          current = +word
+        elsif current.length + 1 + word.length <= max_width
+          current << " " << word
+        else
+          lines << current
+          current = +word
+        end
+      end
+
+      lines << current unless current.empty?
+    end
+
+    lines
+  end
+end

data/examples/16_writers_room/output/.gitignore

@@ -0,0 +1,4 @@
+book.md
+room.log
+memory.json
+screenplay.md

data/examples/16_writers_room/output/README.md

@@ -0,0 +1,69 @@
+# Writers' Room Output
+
+This directory contains the creative works produced by the Writers' Room
+self-organizing robot teams (Demo 16). No human wrote any of the prose,
+outlines, or screenplay content — it all emerged from robots coordinating
+through bus messages and shared memory.
+
+## The Works
+
+### opus_001.md — First Book
+
+The first novella ever produced by the Writers' Room. A team of writer
+robots self-organized to create a 10-chapter science fiction story. They
+discussed the premise, built a story bible, outlined the plot, claimed
+chapters, and wrote them — all without orchestration or assigned roles.
+
+`opus_001_notes.log` contains the session log from that run.
+
+### opus_002.md — Second Book
+
+The second novella produced by the Writers' Room. Same process, same
+self-organizing pattern, different story.
+
+`opus_002_notes.log` contains the session log.
+
+### opus_002_screenplay.md — First Screenplay
+
+The first screenplay the robots ever created. After opus_002 was written,
+the Writers' Room was extended with a screenplay mode that adapts a
+finished book into a 4-act made-for-TV movie pilot.
+
+The workflow:
+
+1. Book mode runs and produces a novella (opus_002.md)
+2. Book mode also dumps all creative artifacts (story bible, outline,
+   chapters) to `memory.json`
+3. Screenplay mode is launched with `--screenplay-from memory.json`,
+   which reloads that memory into the room before the screenwriters start
+4. The screenwriters read the source material, discuss adaptation choices,
+   build a scene outline, and write individual scenes in standard
+   screenplay format
+
+```bash
+# Step 1: Write the book (memory.json is saved automatically)
+bundle exec ruby examples/16_writers_room/writers_room.rb
+
+# Step 2: Adapt it to a screenplay
+bundle exec ruby examples/16_writers_room/writers_room.rb \
+  --screenplay-from examples/16_writers_room/output/memory.json
+```
+
+Screenplay writers work at the scene level — each robot claims and writes
+individual scenes rather than entire acts. They maintain a `scene_registry`
+in shared memory listing all planned scenes, and can drop or reorder
+scenes as the adaptation takes shape. When unclaimed scenes pile up, the
+robots spawn additional writers to help.
+
+`opus_002_screenplay_notes.md` is the log of the robots discussing the
+screenplay adaptation process — debating what to keep, what to cut, how
+to restructure the story for screen, and how to handle act breaks.
+
+## Working Files
+
+These files are generated each run and git-ignored:
+
+- `book.md` — latest book mode output
+- `screenplay.md` — latest screenplay mode output
+- `memory.json` — memory dump from the latest book mode run
+- `room.log` — structured log from the Room (timestamps, tool calls, heartbeats)