riffer-rig 0.9.0 → 0.11.0

data/lib/riffer/rig/loader.rb

@@ -21,6 +21,7 @@ class Riffer::Rig::Loader
   # @rbs @extensions_enabled: bool
   # @rbs @gem_extensions: Array[Riffer::Rig::Extension]
   # @rbs @file_state: Hash[String, Time?]?
+  # @rbs @reload_mode: (:auto | :manual | nil)
 
   # @dynamic tracked_files
   attr_reader :tracked_files #: Array[String]
@@ -37,6 +38,8 @@ class Riffer::Rig::Loader
   # @rbs tools: Array[String]?
   # @rbs max_steps: Integer?
   # @rbs store: Riffer::Rig::Stores::_Store | nil
+  # @rbs reload: (:auto | :manual | nil)
+  # @rbs snapshot: Hash[Symbol, untyped]?
   # @rbs return: Riffer::Rig::Runtime
   def self.runtime(
     cwd:,
@@ -50,10 +53,20 @@ class Riffer::Rig::Loader
     agents_md: true,
     tools: nil,
     max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS,
-    store: Riffer::Rig::Stores::JSONL.new
+    store: Riffer::Rig::Stores::JSONL.new,
+    reload: nil,
+    snapshot: nil
   )
-    new(cwd:, host:, env:, home:, riffer_config:, store:)
-      .runtime(model:, extensions:, skills:, agents_md:, tools:, max_steps:)
+    new(cwd:, host:, env:, home:, riffer_config:, store:).runtime(
+      model:,
+      extensions:,
+      skills:,
+      agents_md:,
+      tools:,
+      max_steps:,
+      reload:,
+      snapshot:
+    )
   end
 
   # @rbs cwd: String
@@ -84,6 +97,7 @@ class Riffer::Rig::Loader
     @extensions_enabled = true
     @gem_extensions = []
     @file_state = nil
+    @reload_mode = nil
   end
 
   # @rbs model: String?
@@ -92,6 +106,8 @@ class Riffer::Rig::Loader
   # @rbs agents_md: bool
   # @rbs tools: Array[String]?
   # @rbs max_steps: Integer?
+  # @rbs reload: (:auto | :manual | nil)
+  # @rbs snapshot: Hash[Symbol, untyped]?
   # @rbs return: Riffer::Rig::Runtime
   def runtime(
     model: nil,
@@ -99,7 +115,9 @@ class Riffer::Rig::Loader
     skills: true,
     agents_md: true,
     tools: nil,
-    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
+    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS,
+    reload: nil,
+    snapshot: nil
   )
     settings = merged_settings
     document = Riffer::Rig::Settings::Document.new(settings)
@@ -108,13 +126,14 @@ class Riffer::Rig::Loader
     ensure_sdk(provider)
     credentials = { provider.to_sym => credentials_for(provider) }
     @extensions_enabled = extensions
+    @reload_mode = reload
     @stripped = { skills: skills, agents_md: agents_md }.reject { |_name, kept| kept }.keys
     loaded = Riffer::Rig::Bundled::BY_NAME.except(*document.disabled.map(&:to_sym), *@stripped).values
     @tracked_files = []
     @gem_extensions = []
     loaded += load_rig_files(document.autoload) if extensions
 
-    recorder = recorder_for(document)
+    recorder = recorder_for(document, resumed: !snapshot.nil?)
     loaded << Riffer::Rig::Stores::Recorder.extension(recorder) if recorder
 
     built = Riffer::Rig::Runtime.new(
@@ -129,25 +148,98 @@ class Riffer::Rig::Loader
       pricing: document.models,
       riffer_config: @riffer_config,
       model_options: Riffer::Rig::Settings.model_options(selected, document.reasoning),
-      native_tools: document.native_tools
+      native_tools: document.native_tools,
+      snapshot: snapshot
     )
     built.install_command(Riffer::Rig::Commands::Reload.command(self))
+    built.install_reload_check(->(runtime) { automatic_reload(runtime) }) unless reload_mode(document) == :manual
     @file_state = file_state
     recorder&.attach(built)
     built
   end
 
+  # @rbs model: String?
+  # @rbs extensions: bool
+  # @rbs skills: bool
+  # @rbs agents_md: bool
+  # @rbs tools: Array[String]?
+  # @rbs max_steps: Integer?
+  # @rbs return: Riffer::Rig::Runtime?
+  def continue(
+    model: nil,
+    extensions: true,
+    skills: true,
+    agents_md: true,
+    tools: nil,
+    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
+  )
+    store = @store
+    return nil unless store
+
+    latest = store.list(cwd: @cwd).max_by { |header| header.updated || Time.at(0) }
+    return nil unless latest
+
+    resume(latest.id, model:, extensions:, skills:, agents_md:, tools:, max_steps:)
+  end
+
+  # A resume carries the history over and nothing else: the settings,
+  # credentials, extensions and tools are today's.
+  # @rbs id: String
+  # @rbs model: String?
+  # @rbs extensions: bool
+  # @rbs skills: bool
+  # @rbs agents_md: bool
+  # @rbs tools: Array[String]?
+  # @rbs max_steps: Integer?
+  # @rbs return: Riffer::Rig::Runtime?
+  def resume(
+    id,
+    model: nil,
+    extensions: true,
+    skills: true,
+    agents_md: true,
+    tools: nil,
+    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
+  )
+    store = @store
+    return nil unless store
+
+    entries = store.read(id)
+    return nil if entries.empty?
+
+    runtime(model:, extensions:, skills:, agents_md:, tools:, max_steps:, snapshot: snapshot_of(entries, id))
+  end
+
+  # @rbs all: bool
+  # @rbs return: Array[::Riffer::Rig::Stores::Header]
+  def list(all: false)
+    store = @store
+    return [] unless store
+
+    all ? store.list : store.list(cwd: @cwd)
+  end
+
+  # @rbs id: String
+  # @rbs return: void
+  def delete(id)
+    store = @store
+    return unless store
+
+    store.delete(id)
+  end
+
   # Without force, a no-op while the tracked file set and the two rig.rb paths
-  # look as the last discovery left them — the entry point the automatic
-  # trigger (#133) calls. The snapshot advances on every attempt, failed ones
-  # included, so a failure does not retry every request. Failures are notified
-  # once and reported as the message, the way Settings.rejection reports a
-  # rejection; the Runtime is the success value.
+  # look as the last discovery left them and the reload mode is not manual —
+  # the entry point the automatic trigger (#133) calls. The snapshot advances
+  # on every attempt, failed ones included, so a failure does not retry every
+  # request. Failures are notified once and reported as the message, the way
+  # Settings.rejection reports a rejection; the Runtime is the success value.
   # @rbs runtime: Riffer::Rig::Runtime
   # @rbs force: bool
   # @rbs return: (Riffer::Rig::Runtime | String)
   def reload(runtime, force: false)
     return runtime if !force && file_state == @file_state
+    return runtime if !force && manual_reload?
 
     outcome = perform_reload(runtime)
     @file_state = file_state
@@ -156,6 +248,27 @@ class Riffer::Rig::Loader
 
   private
 
+  # The reload mode a build runs under: the keyword wins over the setting,
+  # the setting over the default.
+  # @rbs document: Riffer::Rig::Settings::Document
+  # @rbs return: (:auto | :manual)
+  def reload_mode(document)
+    @reload_mode || document.reload
+  end
+
+  # @rbs return: bool
+  def manual_reload?
+    reload_mode(Riffer::Rig::Settings::Document.new(merged_settings)) == :manual
+  end
+
+  # The automatic trigger: runs at every before_request boundary, so the
+  # change check decides and a no-op costs the stat alone.
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs return: void
+  def automatic_reload(runtime)
+    _ = reload(runtime)
+  end
+
   # @rbs return: Hash[Symbol, untyped]
   def merged_settings
     Riffer::Rig::Settings.merge(
@@ -164,28 +277,24 @@ class Riffer::Rig::Loader
     )
   end
 
-  # Notifies every failure once and reports its message; a rebuilt Runtime is
-  # the success value.
+  # Notifies every failure once and reports its message, unexpected raises
+  # included — the automatic check runs mid-turn with no other isolation, and a
+  # raised attempt must still advance the snapshot in reload. A rebuilt Runtime
+  # is the success value.
   # @rbs runtime: Riffer::Rig::Runtime
   # @rbs return: (Riffer::Rig::Runtime | String)
   def perform_reload(runtime)
     settings = merged_settings
     document = Riffer::Rig::Settings::Document.new(settings)
-    begin
-      extensions = reload_extensions(document, settings)
-    rescue AbandonedError => e
-      return notify_failure(e.message)
-    end
+    extensions = reload_extensions(document, settings)
 
     failure = reload_credentials(runtime)
     return notify_failure(failure) if failure
 
-    begin
-      runtime.rebuild(extensions: validated(extensions, settings), settings: settings)
-    rescue StandardError => e
-      return notify_failure(e.message)
-    end
+    runtime.rebuild(extensions: validated(extensions, settings), settings: settings)
     runtime
+  rescue StandardError => e
+    notify_failure(e.message)
   end
 
   # @rbs message: String
@@ -453,15 +562,28 @@ class Riffer::Rig::Loader
     File.join(@home, '.riffer', 'settings.json')
   end
 
+  # @rbs entries: Array[Riffer::Rig::Stores::entry]
+  # @rbs id: String
+  # @rbs return: Hash[Symbol, untyped]
+  def snapshot_of(entries, id)
+    {
+      id: id,
+      messages: entries.filter_map { |entry| entry.message if entry.is_a?(Riffer::Rig::Stores::MessageEntry) },
+      model: entries.filter_map { |entry| entry.model if entry.is_a?(Riffer::Rig::Stores::ModelEntry) }.last,
+      skills: entries.filter_map { |entry| entry.skill if entry.is_a?(Riffer::Rig::Stores::SkillEntry) }
+    }
+  end
+
   # The store records unless it was declined with store: nil or globally with
   # "sessions": {"save": false}.
   # @rbs document: Riffer::Rig::Settings::Document
+  # @rbs resumed: bool
   # @rbs return: Riffer::Rig::Stores::Recorder?
-  def recorder_for(document)
+  def recorder_for(document, resumed:)
     store = @store
     return nil unless document.save
     return nil unless store
 
-    Riffer::Rig::Stores::Recorder.new(store: store)
+    Riffer::Rig::Stores::Recorder.new(store: store, resumed: resumed)
   end
 end

data/lib/riffer/rig/runtime.rb

@@ -66,6 +66,7 @@ class Riffer::Rig::Runtime
   # @rbs @mcp_servers: Hash[String, Riffer::Rig::Mcp::Server]
   # @rbs @model_options: Hash[Symbol, untyped]
   # @rbs @native_tools: Hash[Symbol, untyped]
+  # @rbs @reload_check: (^(::Riffer::Rig::Runtime) -> void)?
 
   # @dynamic agent, credentials, cwd, host, id, settings, declared_settings
   attr_reader :agent #: Riffer::Agent
@@ -122,6 +123,7 @@ class Riffer::Rig::Runtime
     @claim_depth = 0
     @claim_thread = nil
     @core_commands = []
+    @reload_check = nil
     @cancel_flag = Riffer::Rig::Runtime::CancelFlag.new
     @session_start_pending = true
     @session_start_reason = snapshot ? :restore : :new
@@ -187,6 +189,16 @@ class Riffer::Rig::Runtime
     nil
   end
 
+  # Installs a host-of-the-runtime check (the Loader's automatic reload) so it
+  # survives every rebuild. The Runtime calls it at both before_request
+  # boundaries, before any handler runs, and ignores the result.
+  # @rbs check: ^(::Riffer::Rig::Runtime) -> void
+  # @rbs return: nil
+  def install_reload_check(check)
+    @reload_check = check
+    nil
+  end
+
   # @rbs name: String
   # @rbs args: String
   # @rbs &block: ?(::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event) -> void
@@ -448,6 +460,7 @@ class Riffer::Rig::Runtime
   # @rbs return: Enumerator[Riffer::StreamEvents::Base, Riffer::Agent::Response]
   def start_turn(text)
     @cancel_flag.clear
+    @reload_check&.call(self)
     refresh_system_message
     prompt = @hooks.before_prompt(text)
     return blocked_turn(prompt.reason) if prompt.is_a?(Riffer::Rig::Runtime::Blocked)
@@ -554,6 +567,7 @@ class Riffer::Rig::Runtime
 
   # @rbs return: void
   def before_next_request
+    @reload_check&.call(self)
     messages = @agent.session.messages
     # Upstream candidate: riffer has no hook between tool results and the next
     # request, so the last tool result's on_message stands in for one.

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Settings::Document
-  # @dynamic model, reasoning, models, providers, disabled, autoload, native_tools, save
+  # @dynamic model, reasoning, models, providers, disabled, autoload, native_tools, save, reload
   attr_reader :model #: String?
   attr_reader :reasoning #: String?
   attr_reader :models #: Hash[String, Riffer::Rig::Settings::Pricing]
@@ -10,6 +10,7 @@ class Riffer::Rig::Settings::Document
   attr_reader :autoload #: bool
   attr_reader :native_tools #: Hash[Symbol, bool | Hash[Symbol, untyped]]
   attr_reader :save #: bool
+  attr_reader :reload #: (:auto | :manual)
 
   # @rbs source: Hash[Symbol, untyped]
   # @rbs return: void
@@ -31,6 +32,7 @@ class Riffer::Rig::Settings::Document
     @disabled = names.freeze
     @autoload = hash_or_empty(source[:extensions])[:autoload] == true
     @save = hash_or_empty(source[:sessions])[:save] != false
+    @reload = source[:reload] == 'manual' ? :manual : :auto
     @native_tools = hash_or_empty(hash_or_empty(source[:tools])[:native])
                     .select { |_tool, switch| switch == true || switch.is_a?(Hash) }
                     .transform_keys(&:to_sym).freeze

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Stores::Header
+  TYPE = 'header' #: String
+
+  include Riffer::Rig::Support::Equatable
+
+  # @rbs @schema_version: Integer
+  # @rbs @id: String
+  # @rbs @cwd: String
+  # @rbs @created_at: String
+  # @rbs @model: String
+  # @rbs @riffer_rig_version: String
+  # @rbs @riffer_version: String
+  # @rbs @title: String
+  # @rbs @updated: Time?
+
+  # @dynamic schema_version, id, cwd, created_at, model, riffer_rig_version, riffer_version, title, updated
+  attr_reader :schema_version #: Integer
+  attr_reader :id #: String
+  attr_reader :cwd #: String
+  attr_reader :created_at #: String
+  attr_reader :model #: String
+  attr_reader :riffer_rig_version #: String
+  attr_reader :riffer_version #: String
+  attr_reader :title #: String
+  # Store-derived metadata, not entry data: stamped by the store while it
+  # holds the physical artifact (the JSONL file's mtime), so it is excluded
+  # from to_h.
+  attr_reader :updated #: Time?
+
+  # @rbs hash: Hash[Symbol, untyped]
+  # @rbs updated: Time?
+  # @rbs return: ::Riffer::Rig::Stores::Header?
+  def self.from_hash(hash, updated: nil)
+    schema_version = hash[:schema_version]
+    id = hash[:id]
+    cwd = hash[:cwd]
+    created_at = hash[:created_at]
+    model = hash[:model]
+    riffer_rig_version = hash[:riffer_rig_version]
+    riffer_version = hash[:riffer_version]
+    title = hash[:title]
+    return nil unless schema_version.is_a?(Integer)
+    return nil unless [id, cwd, created_at, model, riffer_rig_version, riffer_version, title].all?(String)
+
+    new(
+      schema_version: schema_version,
+      id: id,
+      cwd: cwd,
+      created_at: created_at,
+      model: model,
+      riffer_rig_version: riffer_rig_version,
+      riffer_version: riffer_version,
+      title: title,
+      updated: updated
+    )
+  end
+
+  # @rbs schema_version: Integer
+  # @rbs id: String
+  # @rbs cwd: String
+  # @rbs created_at: String
+  # @rbs model: String
+  # @rbs riffer_rig_version: String
+  # @rbs riffer_version: String
+  # @rbs title: String
+  # @rbs updated: Time?
+  # @rbs return: void
+  def initialize(
+    schema_version:,
+    id:,
+    cwd:,
+    created_at:,
+    model:,
+    riffer_rig_version:,
+    riffer_version:,
+    title:,
+    updated: nil
+  )
+    @schema_version = schema_version
+    @id = id
+    @cwd = cwd
+    @created_at = created_at
+    @model = model
+    @riffer_rig_version = riffer_rig_version
+    @riffer_version = riffer_version
+    @title = title
+    @updated = updated
+    freeze
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    {
+      type: TYPE,
+      schema_version: @schema_version,
+      id: @id,
+      cwd: @cwd,
+      created_at: @created_at,
+      model: @model,
+      riffer_rig_version: @riffer_rig_version,
+      riffer_version: @riffer_version,
+      title: @title
+    }
+  end
+end

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

@@ -6,6 +6,13 @@ require 'json'
 class Riffer::Rig::Stores::JSONL
   HEADER_VERSION = 1 #: Integer
 
+  ENTRY_TYPES = {
+    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::SkillEntry::TYPE => Riffer::Rig::Stores::SkillEntry
+  }.freeze #: Hash[String, Riffer::Rig::Stores::entry_type]
+
   # @rbs @home: String
   # @rbs @paths: Hash[String, String]
 
@@ -17,26 +24,31 @@ class Riffer::Rig::Stores::JSONL
   end
 
   # @rbs id: String
-  # @rbs entry: Hash[Symbol, untyped]
+  # @rbs entry: Riffer::Rig::Stores::entry
   # @rbs return: void
   def append(id, entry)
-    File.write(path_for(id, entry), "#{JSON.generate(entry)}\n", mode: 'a')
+    File.write(path_for(id, entry), "#{JSON.generate(entry.to_h)}\n", mode: 'a')
   end
 
   # @rbs id: String
-  # @rbs return: Array[Hash[Symbol, untyped]]
+  # @rbs return: Array[Riffer::Rig::Stores::entry]
   def read(id)
     path = find(id)
     return [] unless path
 
-    File.foreach(path).filter_map { |line| parse(line) }
+    File.foreach(path).filter_map { |line| entry_of(line) }
   end
 
   # @rbs cwd: String?
-  # @rbs return: Array[Hash[Symbol, untyped]]
+  # @rbs return: Array[::Riffer::Rig::Stores::Header]
   def list(cwd: nil)
-    headers = Dir.glob(File.join(root, '*', '*.jsonl')).filter_map { |path| header_of(path) }
-    cwd ? headers.select { |header| header[:cwd] == cwd } : headers
+    headers = Dir.glob(File.join(root, '*', '*.jsonl')).filter_map do |path|
+      # Seeding the path cache here keeps picking the most recently updated
+      # session one mtime per header instead of one glob.
+      @paths[File.basename(path, '.jsonl')] = path
+      header_of(path)
+    end
+    cwd ? headers.select { |header| header.cwd == cwd } : headers
   end
 
   # @rbs id: String
@@ -57,11 +69,11 @@ class Riffer::Rig::Stores::JSONL
   end
 
   # @rbs id: String
-  # @rbs entry: Hash[Symbol, untyped]
+  # @rbs entry: Riffer::Rig::Stores::entry
   # @rbs return: String
   def path_for(id, entry)
     @paths.fetch(id) do
-      path = entry[:type] == 'header' ? new_path(id, entry.fetch(:cwd)) : find(id)
+      path = entry.is_a?(Riffer::Rig::Stores::Header) ? new_path(id, entry.cwd) : find(id)
       raise ArgumentError, "no session file for #{id}" unless path
 
       @paths[id] = path
@@ -77,14 +89,6 @@ class Riffer::Rig::Stores::JSONL
     File.join(dir, "#{id}.jsonl")
   end
 
-  # @rbs path: String
-  # @rbs return: Hash[Symbol, untyped]?
-  def header_of(path)
-    line = File.foreach(path).first
-    entry = parse(line) if line
-    entry if entry.is_a?(Hash) && entry[:type] == 'header'
-  end
-
   # @rbs id: String
   # @rbs return: String?
   def find(id)
@@ -105,6 +109,28 @@ class Riffer::Rig::Stores::JSONL
     slug.empty? || slug.match?(/\A\.{1,2}\z/) ? '-' : slug
   end
 
+  # A session's last update is its file's mtime: appends are the only writes.
+  # The store stamps it while it holds the artifact, so the listed header
+  # carries it.
+  # @rbs path: String
+  # @rbs return: ::Riffer::Rig::Stores::Header?
+  def header_of(path)
+    line = File.foreach(path).first
+    hash = parse(line) if line
+    return nil unless hash && hash[:type] == Riffer::Rig::Stores::Header::TYPE
+
+    Riffer::Rig::Stores::Header.from_hash(hash, updated: File.mtime(path))
+  end
+
+  # @rbs line: String
+  # @rbs return: Riffer::Rig::Stores::entry?
+  def entry_of(line)
+    hash = parse(line)
+    return nil unless hash
+
+    ENTRY_TYPES[hash[:type]]&.from_hash(hash)
+  end
+
   # @rbs line: String
   # @rbs return: Hash[Symbol, untyped]?
   def parse(line)

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Stores::MessageEntry
+  TYPE = 'message' #: String
+
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic message
+  attr_reader :message #: Hash[Symbol, untyped]
+
+  # @rbs hash: Hash[Symbol, untyped]
+  # @rbs return: ::Riffer::Rig::Stores::MessageEntry?
+  def self.from_hash(hash)
+    message = hash[:message]
+    return nil unless message.is_a?(Hash)
+
+    new(message: message)
+  end
+
+  # @rbs message: Hash[Symbol, untyped]
+  # @rbs return: void
+  def initialize(message:)
+    @message = message
+    freeze
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: TYPE, message: @message }
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Stores::ModelEntry
+  TYPE = 'model' #: String
+
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic model
+  attr_reader :model #: String
+
+  # @rbs hash: Hash[Symbol, untyped]
+  # @rbs return: ::Riffer::Rig::Stores::ModelEntry?
+  def self.from_hash(hash)
+    model = hash[:model]
+    return nil unless model.is_a?(String)
+
+    new(model: model)
+  end
+
+  # @rbs model: String
+  # @rbs return: void
+  def initialize(model:)
+    @model = model
+    freeze
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: TYPE, model: @model }
+  end
+end