riffer-rig 0.13.0 → 0.15.0

data/lib/riffer/rig/settings/model_options.rb

@@ -3,12 +3,6 @@
 module Riffer::Rig::Settings::ModelOptions
   extend self
 
-  REASONING_LEVELS_BY_PROVIDER = {
-    'anthropic' => %w[low medium high xhigh max].freeze,
-    'openai' => %w[low medium high xhigh].freeze,
-    'openrouter' => %w[low medium high xhigh].freeze
-  }.freeze #: Hash[String, Array[String]]
-
   MODEL_STRING = %r{\A(?<provider>[^/\s]+)/\S+\z} #: Regexp
 
   # @rbs model: String
@@ -26,39 +20,25 @@ module Riffer::Rig::Settings::ModelOptions
     "#{model} is not a provider/name model string; the provider is one of: #{Riffer::Rig::Providers.list}"
   end
 
-  # @rbs model: String
-  # @rbs reasoning: String?
-  # @rbs return: Hash[Symbol, untyped]
-  def model_options(model, reasoning)
-    provider = provider_for(model)
-    levels = (provider && REASONING_LEVELS_BY_PROVIDER[provider]) || []
-    level = reasoning if levels.include?(reasoning)
-    base_options(provider).merge(reasoning_options(level, provider))
+  # @rbs level: String?
+  # @rbs return: String?
+  def reasoning_level(level)
+    level if level && Riffer::Agent::Config::REASONING_LEVELS.include?(level.to_sym)
   end
 
-  private
-
-  # @rbs provider: String?
-  # @rbs return: Hash[Symbol, untyped]
-  def base_options(provider)
-    return { cache_control: { type: :ephemeral } } if provider == 'anthropic'
+  # @rbs level: String
+  # @rbs return: String?
+  def reasoning_rejection(level)
+    return if reasoning_level(level)
 
-    {}
+    "#{level} is not a reasoning level; riffer accepts: #{Riffer::Agent::Config::REASONING_LEVELS.join(' ')}"
   end
 
-  # @rbs level: String?
-  # @rbs provider: String?
+  # @rbs model: String
   # @rbs return: Hash[Symbol, untyped]
-  def reasoning_options(level, provider)
-    return {} unless level
+  def model_options(model)
+    return { cache_control: { type: :ephemeral } } if provider_for(model) == 'anthropic'
 
-    case provider
-    when 'anthropic'
-      { output_config: { effort: level } }
-    when 'openai', 'openrouter'
-      { reasoning: level }
-    else
-      {}
-    end
+    {}
   end
 end

data/lib/riffer/rig/settings.rb

@@ -15,7 +15,10 @@ module Riffer::Rig::Settings
     if home_mcp.is_a?(Hash) && project_mcp.is_a?(Hash)
       merged = merged.merge(mcp: Riffer::Rig::Mcp.merge(home_mcp, project_mcp))
     end
-    disabled = [home, project].flat_map { |scope| Document.new(scope).disabled }.uniq
+    documents = [home, project].map { |scope| Document.new(scope) }
+    disabled = documents.flat_map(&:disabled).uniq
+    catalog_files = documents.flat_map(&:catalog_files).uniq
+    merged = merged.merge(catalog_files: catalog_files) if catalog_files.any?
     return merged if disabled.empty?
 
     extensions = merged[:extensions].is_a?(Hash) ? merged[:extensions] : {} #: Hash[Symbol, untyped]

data/lib/riffer/rig/stores/entries.rb

@@ -17,6 +17,9 @@ module Riffer::Rig::Stores::Entries
       id: id,
       messages: messages(entries),
       model: entries.filter_map { |entry| entry.model if entry.is_a?(Riffer::Rig::Stores::ModelEntry) }.last,
+      reasoning: entries.filter_map do |entry|
+        entry.reasoning if entry.is_a?(Riffer::Rig::Stores::ReasoningEntry)
+      end.last,
       skills: entries.filter_map { |entry| entry.skill if entry.is_a?(Riffer::Rig::Stores::SkillEntry) }
     }
   end

data/lib/riffer/rig/stores/jsonl.rb

@@ -10,6 +10,7 @@ class Riffer::Rig::Stores::JSONL
     Riffer::Rig::Stores::Header.type => Riffer::Rig::Stores::Header,
     Riffer::Rig::Stores::MessageEntry.type => Riffer::Rig::Stores::MessageEntry,
     Riffer::Rig::Stores::ModelEntry.type => Riffer::Rig::Stores::ModelEntry,
+    Riffer::Rig::Stores::ReasoningEntry.type => Riffer::Rig::Stores::ReasoningEntry,
     Riffer::Rig::Stores::SkillEntry.type => Riffer::Rig::Stores::SkillEntry
   }.freeze #: Hash[String, Riffer::Rig::Stores::entry_type]
 

data/lib/riffer/rig/stores/reasoning_entry.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Stores::ReasoningEntry
+  extend Riffer::Rig::Support::TypedValue::Schema #[String]
+  include Riffer::Rig::Support::TypedValue #[String]
+  include Riffer::Rig::Stores::Stamped
+
+  typed_value 'reasoning', :reasoning, :recorded_at
+
+  # @dynamic reasoning, recorded_at
+  attr_reader :reasoning #: String
+  attr_reader :recorded_at #: String?
+
+  # @rbs hash: Hash[Symbol, untyped]
+  # @rbs return: ::Riffer::Rig::Stores::ReasoningEntry?
+  def self.from_hash(hash)
+    reasoning = hash[:reasoning]
+    return nil unless reasoning.is_a?(String)
+
+    new(reasoning: reasoning, recorded_at: Riffer::Rig::Stores::Timestamp.dump(Riffer::Rig::Stores::Timestamp.load(hash[:recorded_at])))
+  end
+
+  # @rbs reasoning: String
+  # @rbs recorded_at: String?
+  # @rbs return: void
+  def initialize(reasoning:, recorded_at: nil)
+    @reasoning = reasoning
+    @recorded_at = recorded_at
+    freeze
+  end
+end

data/lib/riffer/rig/stores/recorder.rb

@@ -15,10 +15,10 @@ class Riffer::Rig::Stores::Recorder
 
   # Records one Loader-built session into the store: the header on the first
   # message (its title needs the first prompt), one entry per message, one per
-  # model switch and one per skill activation. Entries that land before the
-  # first message (a /model before the first prompt) wait for the header. A
-  # resumed session appends to the file its first run wrote, so it rewrites
-  # no header.
+  # model switch, one per reasoning switch and one per skill activation. Entries
+  # that land before the first message (a /model before the first prompt) wait
+  # for the header. A resumed session appends to the file its first run wrote,
+  # so it rewrites no header.
   # @rbs store: Riffer::Rig::Stores::_Store
   # @rbs resumed: bool
   # @rbs clock: singleton(Time)
@@ -40,6 +40,7 @@ class Riffer::Rig::Stores::Recorder
     @last_recorded_at = last_recorded_at(runtime.id) if @resumed
     runtime.on_message { |message| message(message) }
     runtime.on_model_change { |model| switched(model) }
+    runtime.on_reasoning_change { |level| switched_reasoning(level) }
   end
 
   # @rbs event: Riffer::StreamEvents::SkillActivation
@@ -63,6 +64,12 @@ class Riffer::Rig::Stores::Recorder
     record(Riffer::Rig::Stores::ModelEntry.new(model: model, recorded_at: Riffer::Rig::Stores::Timestamp.dump(stamp)))
   end
 
+  # @rbs level: String
+  # @rbs return: void
+  def switched_reasoning(level)
+    record(Riffer::Rig::Stores::ReasoningEntry.new(reasoning: level, recorded_at: Riffer::Rig::Stores::Timestamp.dump(stamp)))
+  end
+
   # The extension rides the build as its last extension, so its :stream hook
   # sees the model's skill activations. Per build, unlike the extensions in
   # the process registry: the hook closes over this build's recorder.

data/lib/riffer/rig/terminal/console.rb

@@ -3,25 +3,37 @@
 class Riffer::Rig::Terminal::Console
   # @rbs @frame: Riffer::Rig::Terminal::Frame
   # @rbs @pipeline: Riffer::Rig::Terminal::KeyPipeline
+  # @rbs @loading: Riffer::Rig::Terminal::Loading
+  # @rbs @idle: Riffer::Rig::Terminal::IdleTicker
 
   # @rbs frame: Riffer::Rig::Terminal::Frame
   # @rbs pipeline: Riffer::Rig::Terminal::KeyPipeline
+  # @rbs loading: Riffer::Rig::Terminal::Loading
+  # @rbs idle: Riffer::Rig::Terminal::IdleTicker
   # @rbs return: void
-  def initialize(frame:, pipeline:)
+  def initialize(frame:, pipeline:, loading:, idle:)
     @frame = frame
     @pipeline = pipeline
+    @loading = loading
+    @idle = idle
   end
 
   # @rbs return: void
   def start
+    # The first tick pushes the animated line before the frame draws, so the
+    # loading row is animated from its first write.
+    @loading.start
     @frame.start
+    @idle.start
     @pipeline.start
   end
 
   # @rbs return: void
   def stop
     @pipeline.stop
+    @idle.stop
     @frame.stop
+    @loading.stop
   end
 
   # @rbs *chunks: String

data/lib/riffer/rig/terminal/count.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Terminal::Count
+  extend self
+
+  # @rbs amount: Integer
+  # @rbs return: String
+  def call(amount)
+    return amount.to_s if amount < 1_000
+    return "#{format('%g', amount.fdiv(1_000).floor(amount < 100_000 ? 1 : 0))}k" if amount < 1_000_000
+
+    "#{format('%g', amount.fdiv(1_000_000).floor(amount < 100_000_000 ? 1 : 0))}M"
+  end
+end

data/lib/riffer/rig/terminal/frame.rb

@@ -7,15 +7,15 @@ class Riffer::Rig::Terminal::Frame
 
   PROMPT_COLUMNS = 2 #: Integer
 
+  INDENT = ' ' * PROMPT_COLUMNS #: String
+
   STATUS_INDENT = '  ' #: String
 
   # The first column is the cursor's own cell when it rests at the end of the
   # text.
   QUEUED_GAP = '   ' #: String
 
-  JOBS_SEPARATOR = ' · ' #: String
-
-  FOOTER_ROWS = 3 #: Integer
+  INPUT_ROWS = 8 #: Integer
 
   PEEK_ROWS = 8 #: Integer
 
@@ -28,8 +28,15 @@ class Riffer::Rig::Terminal::Frame
   # Sent from the top row the frame drew, so this wipes all of it.
   ERASE = "\r\e[J" #: String
 
+  LOADING = 'loading…' #: String
+
   SPACER = "\r\n" #: String
 
+  # Marks the cursor's cell in the text handed to the wrapper, so the wrapped
+  # row and column can be read back off it: a private-use code point, which no
+  # terminal draws.
+  CURSOR = "\uE000" #: String
+
   # @rbs @io: IO
   # @rbs @theme: Riffer::Rig::Terminal::Theme
   # @rbs @editor: Riffer::Rig::Terminal::LineEditor
@@ -43,6 +50,10 @@ class Riffer::Rig::Terminal::Frame
   # @rbs @height: Integer
   # @rbs @width: Integer
   # @rbs @active: bool
+  # @rbs @loading: bool
+  # @rbs @loading_line: String
+  # @rbs @tally: (^() -> Riffer::Providers::TokenUsage?)?
+  # @rbs @now: ^() -> Time
   # @rbs @mutex: Mutex
   # @rbs @previous_resize: Signal::trap_command
 
@@ -63,8 +74,10 @@ class Riffer::Rig::Terminal::Frame
   # @rbs io: IO
   # @rbs theme: Riffer::Rig::Terminal::Theme
   # @rbs editor: Riffer::Rig::Terminal::LineEditor
+  # @rbs loading: bool
+  # @rbs now: ^() -> Time
   # @rbs return: void
-  def initialize(io:, theme:, editor: Riffer::Rig::Terminal::LineEditor.new)
+  def initialize(io:, theme:, editor: Riffer::Rig::Terminal::LineEditor.new, loading: false, now: -> { Time.now })
     @io = io
     @theme = theme
     @editor = editor
@@ -78,6 +91,10 @@ class Riffer::Rig::Terminal::Frame
     @height = 0
     @width = 0
     @active = false
+    @loading = loading
+    @loading_line = LOADING
+    @tally = nil
+    @now = now
     @mutex = Mutex.new
     @previous_resize = nil
   end
@@ -101,6 +118,9 @@ class Riffer::Rig::Terminal::Frame
   def append(content)
     lines = content.end_with?("\n") ? content : "#{content}\n"
     @mutex.synchronize do
+      # The first content and the footer it draws go out in this one write, so
+      # this is where the loading screen ends.
+      @loading = false
       # The key pipeline's raw mode turns off output post-processing, so a
       # bare line feed would not return the carriage.
       @active ? draw("#{erase}#{lines.gsub(/\r?\n/, "\r\n")}") : write(lines)
@@ -136,6 +156,22 @@ class Riffer::Rig::Terminal::Frame
     end
   end
 
+  # @rbs line: String
+  # @rbs return: void
+  def loading(line)
+    @mutex.synchronize do
+      @loading_line = line
+      # A tick still in flight once the banner drew would otherwise redraw the
+      # footer under it.
+      redraw if @loading
+    end
+  end
+
+  # @rbs return: bool
+  def loading?
+    @mutex.synchronize { @loading }
+  end
+
   # @rbs hint: String?
   # @rbs return: void
   def hint(hint)
@@ -163,9 +199,30 @@ class Riffer::Rig::Terminal::Frame
     end
   end
 
+  # @rbs tally: ^() -> Riffer::Providers::TokenUsage?
+  # @rbs return: void
+  def session(tally:)
+    @mutex.synchronize do
+      @tally = tally
+      redraw
+    end
+  end
+
+  # @rbs return: void
+  def idle_tick
+    @mutex.synchronize do
+      redraw if idle_bar_showing?
+    end
+  end
+
   # @rbs return: Integer
   def status_room
-    @mutex.synchronize { [status_columns(@width - 1), 0].max }
+    @mutex.synchronize { [(@width - 1) - STATUS_INDENT.size, 0].max }
+  end
+
+  # @rbs return: Integer
+  def job_count
+    @mutex.synchronize { @jobs }
   end
 
   # @rbs content: String
@@ -183,6 +240,9 @@ class Riffer::Rig::Terminal::Frame
       return unless @active
 
       @active = false
+      # Ends the loading animation's thread, which stops itself from its next
+      # tick once the row it draws is gone.
+      @loading = false
       write(erase)
     end
     Signal.trap('WINCH', @previous_resize)
@@ -216,13 +276,26 @@ class Riffer::Rig::Terminal::Frame
   # @rbs before: String
   # @rbs return: void
   def draw(before = '')
+    return draw_loading(before) if @loading
+
+    shown, row, column = input_rows
     # A row scrolled off the top of the screen could never be erased again.
-    above = [@height - FOOTER_ROWS, 0].max
+    # The status sits under the input and the spacer above everything drawn.
+    above = [@height - shown.size - 3, 0].max
     palette = palette_rows([above, PALETTE_ROWS].min)
-    spacer = SPACER if @height >= FOOTER_ROWS
-    rows = [*spacer, *peek_rows([above - palette.size, PEEK_ROWS].min), *palette]
-    write("#{before}#{rows.join}#{footer}")
-    @rows_above = rows.size
+    spacer = SPACER if @height >= shown.size + 3
+    lead = [*spacer, *peek_rows([above - palette.size, PEEK_ROWS].min), *palette]
+    write("#{before}#{lead.join}#{footer(shown, row, column)}")
+    @rows_above = lead.size + row
+  end
+
+  # The cursor stays on the row the loading line was written to, so the erase
+  # that replaces it wipes it like the footer's own row.
+  # @rbs before: String
+  # @rbs return: void
+  def draw_loading(before)
+    line = "#{STATUS_INDENT}#{@theme.dim(@loading_line)}"
+    write("#{before}#{Riffer::Rig::Terminal::Columns.head(line, @width - 1)}")
   end
 
   # @rbs limit: Integer
@@ -263,36 +336,89 @@ class Riffer::Rig::Terminal::Frame
     "#{Riffer::Rig::Terminal::Columns.head("#{label}#{DESCRIPTION_GAP}#{@theme.dim(about)}", @width - 1)}\r\n"
   end
 
-  # @rbs return: String
-  def footer
+  # The input rows as drawn, the row the cursor sits on among them, and its
+  # column on that row.
+  # @rbs return: [Array[String], Integer, Integer]
+  def input_rows
+    return viewport if typing < 1
+
     # The last column stays empty: a glyph written there leaves the cursor
     # in a pending wrap, which terminals resolve differently.
-    room = @width - 1
-    typing = [room - PROMPT_COLUMNS, 0].max
-    before = Riffer::Rig::Terminal::Columns.tail(@editor.printable_before, typing)
-    after = Riffer::Rig::Terminal::Columns.head(
-      @editor.printable_after,
-      typing - Riffer::Rig::Terminal::Columns.width(before)
-    )
-    typed = "#{before}#{after}"
+    # The echo shows the text Enter will send, so its spaces are never folded.
+    wrapper = Riffer::Rig::Terminal::Wrapper.new(width: @width - 1, indent: PROMPT_COLUMNS, verbatim: true)
+    wrapped = "#{wrapper << "#{@editor.printable_before}#{CURSOR}#{@editor.printable_after}"}#{wrapper.flush}"
+    rows = wrapped.lines(chomp: true)
+    row = rows.index { |line| line.include?(CURSOR) } || 0
+    prefix = rows.fetch(row).partition(CURSOR).first.delete_prefix(INDENT)
+    column = PROMPT_COLUMNS + Riffer::Rig::Terminal::Columns.width(prefix)
+
+    first = (rows.size - input_cap).clamp(0, row)
+    shown = rows.drop(first).take(input_cap).map do |line|
+      line.delete_prefix(INDENT).sub(CURSOR, '')
+    end
+    row -= first
+    shown[row] = ghosted(shown.fetch(row))
+    last = shown.last
+    chip = chip(typing, Riffer::Rig::Terminal::Columns.width(last))
+    # The chip rides flush right, so a chip appearing pads the row out to it
+    # rather than moving the prompt or the text.
+    shown[-1] = chip.empty? ? last : "#{last}#{' ' * (typing - Riffer::Rig::Terminal::Columns.width(last) - Riffer::Rig::Terminal::Columns.width(chip))}#{chip}"
+    prompted = shown.each_with_index.map do |line, offset|
+      if (first + offset).zero?
+        "#{@theme.pink(PROMPT)} #{line}"
+      else
+        "#{INDENT}#{line}"
+      end
+    end
+    [prompted, row, column]
+  end
+
+  # @rbs return: Integer
+  def input_cap
+    (@height - 1).clamp(1, INPUT_ROWS)
+  end
+
+  # @rbs line: String
+  # @rbs return: String
+  def ghosted(line)
     ghost = Riffer::Rig::Terminal::Columns.head(
       @completion&.ghost.to_s,
-      typing - Riffer::Rig::Terminal::Columns.width(typed)
+      typing - Riffer::Rig::Terminal::Columns.width(line)
     )
-    shown = "#{typed}#{@theme.dim(ghost) unless ghost.empty?}"
-    spare = typing - Riffer::Rig::Terminal::Columns.width(shown)
-    input = Riffer::Rig::Terminal::Columns.head("#{@theme.pink(PROMPT)} #{shown}#{chip(spare)}", room)
-    column = [PROMPT_COLUMNS + Riffer::Rig::Terminal::Columns.width(before), room].min
-    "#{input}\r\n#{status_line(room)}\e[1A\e[#{column + 1}G"
+    "#{line}#{@theme.dim(ghost) unless ghost.empty?}"
   end
 
-  # @rbs room: Integer
+  # @rbs return: Integer
+  def typing
+    @width - 1 - PROMPT_COLUMNS
+  end
+
+  # The wrapped rows need a column for the prompt and one of text; on a
+  # narrower terminal the input stays the one-row viewport, cut to fit.
+  # @rbs return: [Array[String], Integer, Integer]
+  def viewport
+    room = @width - 1
+    [[Riffer::Rig::Terminal::Columns.head("#{@theme.pink(PROMPT)} ", room)], 0, room]
+  end
+
+  # @rbs rows: Array[String]
+  # @rbs row: Integer
+  # @rbs column: Integer
+  # @rbs return: String
+  def footer(rows, row, column)
+    "#{rows.join("\r\n")}\r\n\r\n#{status_line(@width - 1)}\e[#{rows.size - row + 1}A\e[#{column + 1}G"
+  end
+
+  # @rbs typing: Integer
+  # @rbs text: Integer
   # @rbs return: String
-  def chip(room)
+  def chip(typing, text)
+    return '' if @queued.zero?
+
     label = "· #{@queued} queued"
     # A count cut short would read as a smaller queue, so the chip is drawn
-    # whole or not at all.
-    return '' if @queued.zero? || QUEUED_GAP.size + label.size > room
+    # whole or not at all — and only where it leaves the text alone.
+    return '' if QUEUED_GAP.size + label.size + text > typing
 
     "#{QUEUED_GAP}#{@theme.dim(label)}"
   end
@@ -302,32 +428,31 @@ class Riffer::Rig::Terminal::Frame
   def status_line(room)
     # A running ticker sets the status on every tick, so a hint outranks it
     # rather than being drawn over.
-    shown = @hint || @status
-    label = counter(room)
-    return Riffer::Rig::Terminal::Columns.head("#{STATUS_INDENT}#{shown}", room) unless label
-
-    # The counter is the only sign that a job is still running, so the status
-    # is the one cut to make room.
-    status = Riffer::Rig::Terminal::Columns.head(shown, status_columns(room))
-    # A status cut to nothing still carries its styles.
-    trailer = Riffer::Rig::Terminal::Columns.width(status).zero? ? label : "#{JOBS_SEPARATOR}#{label}"
-    "#{STATUS_INDENT}#{status}#{@theme.dim(trailer)}"
+    shown = idle_bar_showing? ? idle_bar([room - STATUS_INDENT.size, 0].max) : (@hint || @status)
+    Riffer::Rig::Terminal::Columns.head("#{STATUS_INDENT}#{shown}", room)
   end
 
-  # @rbs room: Integer
-  # @rbs return: Integer
-  def status_columns(room)
-    label = counter(room)
-    room - STATUS_INDENT.size - (label ? JOBS_SEPARATOR.size + label.size : 0)
+  # @rbs return: bool
+  def idle_bar_showing?
+    !@loading && @hint.nil? && @status.empty? && !@tally.nil?
   end
 
   # @rbs room: Integer
-  # @rbs return: String?
-  def counter(room)
-    label = "#{@jobs} #{@jobs == 1 ? 'job' : 'jobs'} running"
-    # A count cut short would read as fewer jobs, so the counter is drawn
-    # whole or not at all.
-    label unless @jobs.zero? || STATUS_INDENT.size + label.size > room
+  # @rbs return: String
+  def idle_bar(room)
+    tally = @tally
+    return '' unless tally
+
+    usage = tally.call
+    Riffer::Rig::Terminal::StatusBar.idle(
+      clock: @now.call.strftime('%H:%M'),
+      up_tokens: usage&.input_tokens || 0,
+      down_tokens: usage&.output_tokens || 0,
+      cost: usage&.cost || 0.0,
+      jobs: @jobs,
+      theme: @theme,
+      room: room
+    )
   end
 
   # @rbs bytes: String

data/lib/riffer/rig/terminal/frame_prompter.rb

@@ -46,7 +46,9 @@ class Riffer::Rig::Terminal::FramePrompter
       # Raw mode delivers Ctrl-C as a key instead of the signal a blocking
       # read is interrupted by.
       raise Interrupt if key.name == :ctrl_c
-      return editor if key.name == :enter
+      # A prompt answer is one value, so every Enter-flavoured key sends it:
+      # the editor's newline keys exist for the prompt line, not for answers.
+      return editor if key.name == :enter || Riffer::Rig::Terminal::LineEditor::NEWLINE_KEYS.include?(key.name)
 
       editor = editor.press(key)
       @frame.input(editor) unless secret

data/lib/riffer/rig/terminal/idle_ticker.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Terminal::IdleTicker
+  TICK_SECONDS = 1.0 #: Float
+
+  # @rbs @footer: Riffer::Rig::Terminal::Frame
+  # @rbs @halt: Thread::Queue[true]
+  # @rbs @thread: Thread?
+
+  # @rbs footer: Riffer::Rig::Terminal::Frame
+  # @rbs return: void
+  def initialize(footer:)
+    @footer = footer
+    @halt = Queue.new
+    @thread = nil
+  end
+
+  # @rbs return: void
+  def start
+    @thread = Thread.new { @footer.idle_tick until @halt.pop(timeout: TICK_SECONDS) }
+  end
+
+  # @rbs return: void
+  def stop
+    @halt << true
+    @thread&.join
+  end
+end