riffer-rig 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01f34d2a4cb9347ea2d9f7a81a0969415c98b6622d4f78e123034f9b2c15509e
-  data.tar.gz: 5a61c231fcf2832a514ec62513bdf42e56c87dc08ec994f9fb04fa263188b53d
+  metadata.gz: e833f2a4dfe0b87598e2be9d585f3cb772562ab39a2dd528684a38dca87f63ab
+  data.tar.gz: f469b328103a49e52773c0073e02d8c2fbd06d8cf6779daa50c09b49ab2eba8e
 SHA512:
-  metadata.gz: 1b8518928f77909373cfdfe2783372aa1a6ebb04fed67a70951041c0adf637bf3aba0ee8b85051f9bdb63c1cdcda91554b2fd9c86b4f82a279eed30964984588
-  data.tar.gz: 3cd5548405bcf8607d516e7f8a585cdf327cfc904e1641458aca4802e8a3654127c6ed44a46435003faeca1eaaafcd4bed0968c0787a90aca8c586438b685146
+  metadata.gz: 696e8b92a7c1b7a3b71e1f628894e89aed725fbe072dba712d94df277fc5730b06d74def094445b02842d0849409b7900038aedf5d65f29f5416d1450a5b5121
+  data.tar.gz: 3dc42ac6e625d292462e00119bd7b3c7a8d1f23ad3c4f66763fff96cbfc3328f962dca67bdc4613e884ba81a6e3f61d9af86f1ba1d8bbd16e0f3caa307ca453c

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.4.0](https://github.com/bottrall/riffer-rig/compare/v0.3.0...v0.4.0) (2026-09-13)
+
+
+### Features
+
+* **ui:** one blank line between blocks, prompt-owned gaps ([#170](https://github.com/bottrall/riffer-rig/issues/170)) ([636e4d8](https://github.com/bottrall/riffer-rig/commit/636e4d82a069f158775043037a43e2aa494f56dc))
+
+
+### Bug Fixes
+
+* **lint:** adjust rubocop rules and reformat to match ([#168](https://github.com/bottrall/riffer-rig/issues/168)) ([56b81aa](https://github.com/bottrall/riffer-rig/commit/56b81aa904609f246340c8b8135ee7e57791abdd))
+
 ## [0.3.0](https://github.com/bottrall/riffer-rig/compare/v0.2.1...v0.3.0) (2026-09-10)
 
 

data/lib/riffer/rig/cli.rb

@@ -101,7 +101,16 @@ module Riffer::Rig::CLI
     loaded  = [Riffer::Rig::CodingAgent::GLOBAL_AGENTS_FILE, File.join(Dir.pwd, 'AGENTS.md')].select { |path| File.file?(path) }
     context = loaded.empty? ? 'none' : loaded.join(', ')
 
-    animator.reveal([Riffer::Rig::UI::Banner.lines(theme, model: model, cwd: Dir.pwd, context: context, skills: count_skills, version: Riffer::Rig::VERSION)])
+    animator.reveal(
+      [Riffer::Rig::UI::Banner.lines(
+        theme,
+        model: model,
+        cwd: Dir.pwd,
+        context: context,
+        skills: count_skills,
+        version: Riffer::Rig::VERSION
+      )]
+    )
   end
 
   # @rbs return: String

data/lib/riffer/rig/coding_agent.rb

@@ -25,32 +25,34 @@ class Riffer::Rig::CodingAgent < Riffer::Agent
 
   max_steps nil
 
-  instructions(lambda do
-    context_files = [GLOBAL_AGENTS_FILE, File.join(Dir.pwd, 'AGENTS.md')]
-      .select { |path| File.file?(path) }
-      .map { |path| "<project_instructions path=\"#{path}\">\n#{File.read(path)}\n</project_instructions>" }
-
-    project_context =
-      if context_files.empty?
-        ''
-      else
-        "\n\n<project_context>\n#{context_files.join("\n\n")}\n</project_context>"
-      end
-
-    <<~PROMPT.chomp + project_context + "\n\nCurrent date: #{Date.today}\nCurrent working directory: #{Dir.pwd}"
-      You are an expert coding assistant running inside riffer-rig, a terminal coding agent. You help the user by reading files, running shell commands, editing code, and writing new files.
-
-      Available tools:
-      - read: read a file's contents
-      - write: write content to a file
-      - edit: replace an exact string in a file
-      - bash: run a shell command in the working directory
-
-      Guidelines:
-      - Be concise and direct in your responses.
-      - Show file paths clearly when working with files.
-      - Use bash for file exploration (ls, rg, find) rather than guessing.
-      - Prefer editing existing files over creating new ones.
-    PROMPT
-  end)
+  instructions(
+    lambda do
+      context_files = [GLOBAL_AGENTS_FILE, File.join(Dir.pwd, 'AGENTS.md')]
+        .select { |path| File.file?(path) }
+        .map { |path| "<project_instructions path=\"#{path}\">\n#{File.read(path)}\n</project_instructions>" }
+
+      project_context =
+        if context_files.empty?
+          ''
+        else
+          "\n\n<project_context>\n#{context_files.join("\n\n")}\n</project_context>"
+        end
+
+      <<~PROMPT.chomp + project_context + "\n\nCurrent date: #{Date.today}\nCurrent working directory: #{Dir.pwd}"
+        You are an expert coding assistant running inside riffer-rig, a terminal coding agent. You help the user by reading files, running shell commands, editing code, and writing new files.
+
+        Available tools:
+        - read: read a file's contents
+        - write: write content to a file
+        - edit: replace an exact string in a file
+        - bash: run a shell command in the working directory
+
+        Guidelines:
+        - Be concise and direct in your responses.
+        - Show file paths clearly when working with files.
+        - Use bash for file exploration (ls, rg, find) rather than guessing.
+        - Prefer editing existing files over creating new ones.
+      PROMPT
+    end
+  )
 end

data/lib/riffer/rig/repl.rb

@@ -13,7 +13,6 @@ class Riffer::Rig::REPL
   # @rbs @theme: Riffer::Rig::UI::Theme
   # @rbs @input: untyped
   # @rbs @output: untyped
-  # @rbs @pending_tool_calls: Array[Riffer::StreamEvents::ToolCallDone]
 
   # @rbs ?agent: Riffer::Agent
   # @rbs ?renderer: Riffer::Rig::UI::Renderer
@@ -24,7 +23,16 @@ class Riffer::Rig::REPL
   # @rbs ?smoother: Riffer::Rig::UI::Smoother
   # @rbs ?cursor: Riffer::Rig::UI::Cursor
   # @rbs return: void
-  def initialize(agent:, renderer:, input: $stdin, output: $stdout, theme: Riffer::Rig::UI::Theme.for(output), animator: Riffer::Rig::UI::Animator.new(io: output, theme:), smoother: Riffer::Rig::UI::Smoother.new(io: output, theme:), cursor: Riffer::Rig::UI::Cursor.new(io: output, theme:))
+  def initialize(agent:, renderer:, input: $stdin, output: $stdout, theme: Riffer::Rig::UI::Theme.for(output),
+                 animator: Riffer::Rig::UI::Animator.new(
+                   io: output,
+                   theme:
+                 ), smoother: Riffer::Rig::UI::Smoother.new(
+                   io: output,
+                   theme:
+                 ), cursor: Riffer::Rig::UI::Cursor.new(
+                   io: output, theme:
+                 ))
     @agent = agent
     @renderer = renderer
     @animator = animator
@@ -33,14 +41,13 @@ class Riffer::Rig::REPL
     @theme = theme
     @input = input
     @output = output
-    @pending_tool_calls = []
     @agent.session.on_message { |message| render_tool_result(message) }
   end
 
   # @rbs return: Symbol
   def run
     loop do
-      @output.print("\n#{@theme.pink('›')} ")
+      @renderer.prompt
       line = @input.gets
       break if line.nil?
 
@@ -57,7 +64,7 @@ class Riffer::Rig::REPL
       end
     end
 
-    @output.puts("\n#{@theme.grey('see you on the next riff.')}")
+    print_block { @theme.grey('see you on the next riff.') }
     :done
   end
 
@@ -76,40 +83,32 @@ class Riffer::Rig::REPL
       when Riffer::StreamEvents::ReasoningDone
         @animator.start
       when Riffer::StreamEvents::ToolCallDelta, Riffer::StreamEvents::FinishReasonDone
-        # Round bookkeeping: nothing renders, so the indicator just carries on
-        # (or stays parked while the smoother finishes typing earlier text).
         next
-      when Riffer::StreamEvents::ToolCallDone
-        # Tool call lines are held back so the round's stats line can print
-        # above them (see flush_pending_tool_calls).
-        @pending_tool_calls << event
-        next
-      when Riffer::StreamEvents::SkillActivation, Riffer::StreamEvents::TokenUsageDone
-        # The spinner shares its line with what's about to print, and tool
-        # execution plus the next model invocation emit no events — stop it for
-        # the render, then bring it straight back to cover the silent stretch.
-        # Stats print before any pending tool call lines (see below).
+      when Riffer::StreamEvents::SkillActivation
+        # Tool execution and the next model invocation emit no events, so the
+        # spinner comes straight back on to cover the silent stretch.
         @animator.stop
         @renderer.render(event)
-        flush_pending_tool_calls
+        @animator.start
+        next
+      when Riffer::StreamEvents::TokenUsageDone
+        # Usage renders nothing inline — it flushes below the turn's output.
+        # Restarting here covers the silent tool-execution stretch that follows.
+        @renderer.render(event)
         @animator.start
         next
       else
         @animator.stop
       end
-      flush_pending_tool_calls
       @renderer.render(event)
     end
     @animator.stop
-    flush_pending_tool_calls
     @smoother.finish
-    @output.puts
+    @renderer.flush_usage
   rescue StandardError => e
-    @animator.stop
-    flush_pending_tool_calls
-    @output.puts("\nError: #{e.message}")
-  ensure
     @smoother.finish
+    print_block { @theme.red("Error: #{e.message}") }
+  ensure
     @animator.stop
     @cursor.show
   end
@@ -130,7 +129,7 @@ class Riffer::Rig::REPL
     skills = @agent.context.skills
 
     unless skills
-      @output.puts(@theme.grey('No skills configured.'))
+      print_block { @theme.grey('No skills configured.') }
       return
     end
 
@@ -138,13 +137,13 @@ class Riffer::Rig::REPL
     # a non-mutating Context#read. `activate` marks the skill model-activated as
     # a side effect, which drops it from the model's catalog after manual use.
     body = skills.activate(name)
-    @output.puts(@theme.magenta("✦ skill: #{name}"))
+    print_block { @theme.magenta("✦ skill: #{name}") }
     skill_block(name, body)
   rescue Riffer::ArgumentError
-    @output.puts(@theme.red("Unknown skill: #{name}"))
+    print_block { @theme.red("Unknown skill: #{name}") }
     nil
   rescue StandardError => e
-    @output.puts(@theme.red("Error activating skill: #{e.message}"))
+    print_block { @theme.red("Error activating skill: #{e.message}") }
     nil
   end
 
@@ -155,24 +154,17 @@ class Riffer::Rig::REPL
     "<skill name=\"#{name}\">\n#{body}\n</skill>"
   end
 
-  # Tool call lines print below their round's stats line to reflect the actual
-  # timeline (usage is reported when the model stream closes, after the calls
-  # were decided). ToolCallDone events are therefore held until the stats line
-  # or the next event forces them out. Callers must have the spinner stopped —
-  # the flush renders between their existing stop/start pair.
+  # Chrome lines that never pass through the renderer (errors, exit line) end
+  # their line with a newline but leave the renderer's tool-group state alone —
+  # they can only follow prose, never mid-group.
   #
   # @rbs return: void
-  def flush_pending_tool_calls
-    return if @pending_tool_calls.empty?
-
-    @pending_tool_calls.each { |event| @renderer.render(event) }
-    @pending_tool_calls = []
+  def print_block(&)
+    @output.puts
+    @output.puts(yield)
+    @output.flush
   end
 
-  # Tool results can land mid-animation (tool execution emits no stream events,
-  # so the indicator is up); stop it around the line so its next frame doesn't
-  # erase what we printed.
-  #
   # @rbs message: Riffer::Messages::Base
   # @rbs return: void
   def render_tool_result(message)

data/lib/riffer/rig/tools/bash.rb

@@ -15,7 +15,10 @@ class Riffer::Rig::Tools::Bash < Riffer::Tool
 
   params do
     required :command, String, description: 'The shell command to run'
-    optional :timeout_ms, Integer, description: 'Kill the command after this many milliseconds', default: DEFAULT_TIMEOUT_MS
+    optional :timeout_ms,
+             Integer,
+             description: 'Kill the command after this many milliseconds',
+             default: DEFAULT_TIMEOUT_MS
   end
 
   # @rbs context: Riffer::Agent::Context?

data/lib/riffer/rig/tools/edit.rb

@@ -9,7 +9,10 @@ class Riffer::Rig::Tools::Edit < Riffer::Tool
     required :path, String, description: 'Path to the file (absolute, or relative to the working directory)'
     required :old_string, String, description: 'The exact text to replace'
     required :new_string, String, description: 'The text to replace it with'
-    optional :replace_all, Riffer::Params::Boolean, description: 'Replace all occurrences instead of requiring a unique match', default: false
+    optional :replace_all,
+             Riffer::Params::Boolean,
+             description: 'Replace all occurrences instead of requiring a unique match',
+             default: false
   end
 
   # @rbs context: Riffer::Agent::Context?
@@ -26,7 +29,12 @@ class Riffer::Rig::Tools::Edit < Riffer::Tool
     occurrences = content.scan(old_string).length
 
     return error("old_string not found in #{path}", type: :not_found) if occurrences.zero?
-    return error("old_string is not unique in #{path} (#{occurrences} matches). Pass replace_all or add more context.", type: :ambiguous_match) if occurrences > 1 && !replace_all
+    if occurrences > 1 && !replace_all
+      return error(
+        "old_string is not unique in #{path} (#{occurrences} matches). Pass replace_all or add more context.",
+        type: :ambiguous_match
+      )
+    end
 
     # Block form so backslash sequences in new_string (\0, \1, \\) are inserted
     # literally instead of being interpreted as regexp backreferences.

data/lib/riffer/rig/ui/renderer.rb

@@ -9,6 +9,8 @@ class Riffer::Rig::UI::Renderer
   # @rbs @theme: Riffer::Rig::UI::Theme
   # @rbs @tally: Riffer::Rig::TokenTally?
   # @rbs @smoother: Riffer::Rig::UI::Smoother | PassThroughSmoother?
+  # @rbs @deferred_usage: Riffer::Providers::TokenUsage?
+  # @rbs @prose_gap_pending: bool
 
   # @rbs io: untyped
   # @rbs ?theme: Riffer::Rig::UI::Theme
@@ -20,6 +22,8 @@ class Riffer::Rig::UI::Renderer
     @theme = theme
     @tally = tally
     @smoother = smoother
+    @deferred_usage = nil
+    @prose_gap_pending = false
   end
 
   # @rbs event: Riffer::StreamEvents::Base
@@ -27,33 +31,125 @@ class Riffer::Rig::UI::Renderer
   def render(event)
     case event
     when Riffer::StreamEvents::TextDelta
-      smoother << event.content
+      render_prose(event.content)
     when Riffer::StreamEvents::ToolCallDone
-      drain_smoother
-      @io.puts("\n#{@theme.cyan("⚙ #{event.name}(#{format_arguments(event.arguments)})")}")
+      render_tool_activity(2) { @theme.cyan("⚙ #{event.name}(#{format_arguments(event.arguments)})") }
     when Riffer::StreamEvents::SkillActivation
-      drain_smoother
-      @io.puts("\n#{@theme.magenta("✦ skill: #{event.name}")}")
+      render_block(0) { @theme.magenta("✦ skill: #{event.name}") }
     when Riffer::StreamEvents::Interrupt
-      drain_smoother
-      @io.puts(@theme.dim("[interrupted: #{event.reason}]"))
+      render_block(0) { @theme.dim("[interrupted: #{event.reason}]") }
     when Riffer::StreamEvents::TokenUsageDone
-      drain_smoother
-      render_token_usage(event.token_usage)
+      current = @deferred_usage
+      @deferred_usage = current ? current + event.token_usage : event.token_usage
     end
   end
 
+  # The prompt holds the line open for typed input, so unlike render_block it
+  # ends without a newline. It sits at the renderer so a tool group left open by
+  # the previous turn closes here, and the next turn's blocks open cleanly.
+  #
+  # @rbs return: void
+  def prompt
+    @prose_gap_pending = true
+    @io.puts
+    @io.print("#{@theme.pink('›')} ")
+    @io.flush
+  end
+
+  # Usage arrives per model call but tool results arrive via the session
+  # callback after each call's stream ends, so rendering inline would print the
+  # stats above the results they belong with. Held until the turn's output is
+  # done, then printed as one line below it.
+  #
+  # @rbs return: void
+  def flush_usage
+    usage = @deferred_usage
+    @deferred_usage = nil
+    tally = @tally
+    return unless usage && tally
+
+    tally.add(usage)
+    render_block(0) { @theme.dim(usage_line(usage, tally)) }
+  end
+
   # @rbs message: Riffer::Messages::Base
   # @rbs return: void
   def render_tool_result(message)
     return unless message.is_a?(Riffer::Messages::Tool)
 
+    open_tool_activity
     line = "↳ #{preview(message.content)}"
-    @io.puts(message.error? ? @theme.red(line) : @theme.dim(line))
+    styled = message.error? ? @theme.red(line) : @theme.dim(line)
+    @io.print("    #{styled}\n")
+    @io.flush
   end
 
   private
 
+  # Rule 2 for one-off blocks (skill line, interrupt, stats): one blank line
+  # above, no indent. The smoother drains first so any pending partial prose
+  # block ends cleanly before the gap is written, and any open tool group closes
+  # so the next group opens with its own gap.
+  #
+  # @rbs indent: Integer
+  # @rbs return: void
+  def render_block(indent, &)
+    drain_smoother
+    @io.puts
+    @prose_gap_pending = true
+    @io.puts((' ' * indent) + yield)
+    @io.flush
+  end
+
+  # The blank line above a prose block is written at the first delta after a
+  # non-prose block. Streaming makes "which block is first?" a stateful
+  # question, so the answer is tracked rather than embedded at each render site.
+  #
+  # @rbs content: String
+  # @rbs return: void
+  def render_prose(content)
+    if @prose_gap_pending
+      @prose_gap_pending = false
+      @io.print("\n")
+    end
+    smoother << content
+  end
+
+  # @rbs indent: Integer
+  # @rbs return: void
+  def render_tool_activity(indent, &)
+    open_tool_activity
+    @io.puts((' ' * indent) + yield)
+    @io.flush
+  end
+
+  # Tool-activity lines (⚙ calls, ↳ results) share one blank line above the
+  # group instead of one between each line — the gap goes between groups, not
+  # inside a pair. The group stays open so prose after it pays the closing gap.
+  #
+  # @rbs return: void
+  def open_tool_activity
+    return if @prose_gap_pending
+
+    drain_smoother
+    @io.puts
+    @prose_gap_pending = true
+  end
+
+  # @rbs usage: Riffer::Providers::TokenUsage
+  # @rbs tally: Riffer::Rig::TokenTally
+  # @rbs return: String
+  def usage_line(usage, tally)
+    parts = ["↑#{usage.input_tokens}", "↓#{usage.output_tokens}"]
+    parts << "cache_write:#{usage.cache_write_tokens}" if usage.cache_write_tokens&.positive?
+    parts << "cache_read:#{usage.cache_read_tokens}" if usage.cache_read_tokens&.positive?
+    parts << "session #{tally.total_tokens} tok"
+    cost = tally.estimated_cost
+    parts << format('~$%.4f', cost) if cost
+
+    parts.join(' · ')
+  end
+
   # @rbs return: Riffer::Rig::UI::Smoother | PassThroughSmoother
   def smoother
     @smoother || PassThroughSmoother.new(@io)
@@ -88,25 +184,6 @@ class Riffer::Rig::UI::Renderer
     smoother.drain
   end
 
-  # @rbs usage: Riffer::Providers::TokenUsage
-  # @rbs return: void
-  def render_token_usage(usage)
-    tally = @tally
-    return unless tally
-
-    tally.add(usage)
-
-    parts = ["↑#{usage.input_tokens}", "↓#{usage.output_tokens}"]
-    parts << "cache_write:#{usage.cache_write_tokens}" if usage.cache_write_tokens&.positive?
-    parts << "cache_read:#{usage.cache_read_tokens}" if usage.cache_read_tokens&.positive?
-
-    session_parts = ["session #{tally.total_tokens} tok"]
-    cost = tally.estimated_cost
-    session_parts << format('~$%.4f', cost) if cost
-
-    @io.puts("\n#{@theme.dim("#{parts.join(' · ')}   #{session_parts.join(' · ')}")}")
-  end
-
   # @rbs arguments: String
   # @rbs return: String
   def format_arguments(arguments)

data/lib/riffer/rig/ui/smoother.rb

@@ -25,6 +25,7 @@ class Riffer::Rig::UI::Smoother
   # @rbs @mutex: Mutex
   # @rbs @thread: Thread?
   # @rbs @stop: bool
+  # @rbs @newline_pending: bool
 
   # @rbs io: untyped
   # @rbs ?theme: Riffer::Rig::UI::Theme
@@ -39,6 +40,7 @@ class Riffer::Rig::UI::Smoother
     @mutex = Mutex.new
     @thread = nil
     @stop = false
+    @newline_pending = false
   end
 
   # @rbs return: void
@@ -58,11 +60,14 @@ class Riffer::Rig::UI::Smoother
   # @rbs content: String
   # @rbs return: self
   def <<(content)
-    if enabled?
-      @mutex.synchronize { @backlog << content }
-    else
-      @io.print(content)
-      @io.flush
+    @mutex.synchronize do
+      if enabled?
+        @backlog << content
+      else
+        @io.print(content)
+        @io.flush
+      end
+      @newline_pending = !content.end_with?("\n")
     end
     self
   end
@@ -79,19 +84,30 @@ class Riffer::Rig::UI::Smoother
       return if count.zero?
 
       @carry -= count
-      @io.print(@backlog.slice!(0, count))
+      chunk = @backlog.slice!(0, count) || ''
+      @newline_pending = !chunk.end_with?("\n")
+      @io.print(chunk)
       @io.flush
     end
   end
 
-  # Called before non-delta output so printed order matches stream order.
+  # Called before non-prose output so printed order matches stream order. The
+  # backlog is flushed, then any partial prose block the model left without a
+  # trailing newline gets one, so block spacing never depends on the model's
+  # last character.
   #
   # @rbs return: void
   def drain
     @mutex.synchronize do
-      return if @backlog.empty?
+      unless @backlog.empty?
+        backlog = @backlog.slice!(0, @backlog.length) || ''
+        @newline_pending = !backlog.end_with?("\n")
+        @io.print(backlog)
+      end
+      return unless @newline_pending
 
-      @io.print(@backlog.slice!(0, @backlog.length))
+      @newline_pending = false
+      @io.print("\n")
       @io.flush
     end
   end

data/lib/riffer/rig/version.rb

@@ -2,6 +2,6 @@
 
 module Riffer
   module Rig
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

data/sig/generated/riffer/rig/repl.rbs

@@ -5,8 +5,6 @@ class Riffer::Rig::REPL
 
   SKILL_COMMAND: Regexp
 
-  @pending_tool_calls: Array[Riffer::StreamEvents::ToolCallDone]
-
   @output: untyped
 
   @input: untyped
@@ -57,19 +55,13 @@ class Riffer::Rig::REPL
   # @rbs return: String
   def skill_block: (String name, String body) -> String
 
-  # Tool call lines print below their round's stats line to reflect the actual
-  # timeline (usage is reported when the model stream closes, after the calls
-  # were decided). ToolCallDone events are therefore held until the stats line
-  # or the next event forces them out. Callers must have the spinner stopped —
-  # the flush renders between their existing stop/start pair.
+  # Chrome lines that never pass through the renderer (errors, exit line) end
+  # their line with a newline but leave the renderer's tool-group state alone —
+  # they can only follow prose, never mid-group.
   #
   # @rbs return: void
-  def flush_pending_tool_calls: () -> void
+  def print_block: () ?{ (?) -> untyped } -> void
 
-  # Tool results can land mid-animation (tool execution emits no stream events,
-  # so the indicator is up); stop it around the line so its next frame doesn't
-  # erase what we printed.
-  #
   # @rbs message: Riffer::Messages::Base
   # @rbs return: void
   def render_tool_result: (Riffer::Messages::Base message) -> void

data/sig/generated/riffer/rig/ui/renderer.rbs

@@ -3,13 +3,17 @@
 class Riffer::Rig::UI::Renderer
   RESULT_PREVIEW_LIMIT: Integer
 
-  @io: untyped
+  @prose_gap_pending: bool
 
-  @theme: Riffer::Rig::UI::Theme
+  @deferred_usage: Riffer::Providers::TokenUsage?
+
+  @smoother: Riffer::Rig::UI::Smoother | PassThroughSmoother?
 
   @tally: Riffer::Rig::TokenTally?
 
-  @smoother: Riffer::Rig::UI::Smoother | PassThroughSmoother?
+  @theme: Riffer::Rig::UI::Theme
+
+  @io: untyped
 
   # @rbs io: untyped
   # @rbs ?theme: Riffer::Rig::UI::Theme
@@ -22,12 +26,60 @@ class Riffer::Rig::UI::Renderer
   # @rbs return: void
   def render: (Riffer::StreamEvents::Base event) -> void
 
+  # The prompt holds the line open for typed input, so unlike render_block it
+  # ends without a newline. It sits at the renderer so a tool group left open by
+  # the previous turn closes here, and the next turn's blocks open cleanly.
+  #
+  # @rbs return: void
+  def prompt: () -> void
+
+  # Usage arrives per model call but tool results arrive via the session
+  # callback after each call's stream ends, so rendering inline would print the
+  # stats above the results they belong with. Held until the turn's output is
+  # done, then printed as one line below it.
+  #
+  # @rbs return: void
+  def flush_usage: () -> void
+
   # @rbs message: Riffer::Messages::Base
   # @rbs return: void
   def render_tool_result: (Riffer::Messages::Base message) -> void
 
   private
 
+  # Rule 2 for one-off blocks (skill line, interrupt, stats): one blank line
+  # above, no indent. The smoother drains first so any pending partial prose
+  # block ends cleanly before the gap is written, and any open tool group closes
+  # so the next group opens with its own gap.
+  #
+  # @rbs indent: Integer
+  # @rbs return: void
+  def render_block: (Integer indent) ?{ (?) -> untyped } -> void
+
+  # The blank line above a prose block is written at the first delta after a
+  # non-prose block. Streaming makes "which block is first?" a stateful
+  # question, so the answer is tracked rather than embedded at each render site.
+  #
+  # @rbs content: String
+  # @rbs return: void
+  def render_prose: (String content) -> void
+
+  # @rbs indent: Integer
+  # @rbs return: void
+  def render_tool_activity: (Integer indent) ?{ (?) -> untyped } -> void
+
+  # Tool-activity lines (⚙ calls, ↳ results) share one blank line above the
+  # group instead of one between each line — the gap goes between groups, not
+  # inside a pair. The group stays open so prose after it pays the closing gap.
+  #
+  # @rbs return: void
+  def open_tool_activity: () -> void
+
+  # @rbs usage: Riffer::Providers::TokenUsage
+  # @rbs tally: Riffer::Rig::TokenTally
+  # @rbs return: String
+  def usage_line: (Riffer::Providers::TokenUsage usage, Riffer::Rig::TokenTally tally) -> String
+
   # @rbs return: Riffer::Rig::UI::Smoother | PassThroughSmoother
   def smoother: () -> (Riffer::Rig::UI::Smoother | PassThroughSmoother)
 
@@ -54,10 +106,6 @@ class Riffer::Rig::UI::Renderer
   # @rbs return: void
   def drain_smoother: () -> void
 
-  # @rbs usage: Riffer::Providers::TokenUsage
-  # @rbs return: void
-  def render_token_usage: (Riffer::Providers::TokenUsage usage) -> void
-
   # @rbs arguments: String
   # @rbs return: String
   def format_arguments: (String arguments) -> String

data/sig/generated/riffer/rig/ui/smoother.rbs

@@ -16,6 +16,8 @@ class Riffer::Rig::UI::Smoother
 
   MIN_CHARS_PER_TICK: Rational
 
+  @newline_pending: bool
+
   @stop: bool
 
   @thread: Thread?
@@ -50,7 +52,10 @@ class Riffer::Rig::UI::Smoother
   # @rbs return: void
   def tick: () -> void
 
-  # Called before non-delta output so printed order matches stream order.
+  # Called before non-prose output so printed order matches stream order. The
+  # backlog is flushed, then any partial prose block the model left without a
+  # trailing newline gets one, so block spacing never depends on the model's
+  # last character.
   #
   # @rbs return: void
   def drain: () -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer-rig
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jake Bottrall
@@ -79,8 +79,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.8'
-description: An interactive terminal coding agent (read/write/edit/bash) built on
-  the riffer agentic framework.
+description: An interactive terminal agent (read/write/edit/bash) built on the riffer
+  agentic framework.
 email:
 - jakebottrall@gmail.com
 executables: