riffer-rig 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d49bc7e8176b7eec0bc8cc2249bc39668f9637557db92bdd34c1f4baf9ee7ce0
-  data.tar.gz: c9d563f1ff2de6cbece63dc6735107537bc33fd1b8cefde8541e7e2fc3262f3a
+  metadata.gz: 0bc260756e56f8ed0d89556ef071a3ecb1922b637eb5b10cc0268416e0ceb26d
+  data.tar.gz: b7e6d6314a893ff23f289336b5e3df25f11e032f060272d7656695f1e96e584d
 SHA512:
-  metadata.gz: 7b89243587acc30185f2a0f16ebc5adfb43c860f537ec5f1cab6b7fae116322109f74f49b6e990c7d4d0b48dab1a8db3ec61f804c84b69bb06f3fa14cba2f0d7
-  data.tar.gz: cdb0fdd4d2354fd7ed1625c022e6f0fff02f2a34b3f37babfdf1a443a57427e45bb88fab58edf07cd3cfc9e1ef14ad492589ca847df7ff9339c0695728d21290
+  metadata.gz: edda5ec3d1675966361db52a009328703f0f62340d8d18ea3f5e689f3e9194762fec33804072989f1cb92d357038e03ca9481e7ab9f34eb123964f3f025b8749
+  data.tar.gz: c1953f30afa3a7871291852d3aaeba52a256006732582c82f71ad3245234f1e2a974524b174a801df81096af6effc37186e3a10e11ace5f5be644edbe4ed1c49

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.10.0](https://github.com/bottrall/riffer-rig/compare/v0.9.0...v0.10.0) (2026-10-05)
+
+
+### Features
+
+* continue and resume sessions with -c and -r ([#220](https://github.com/bottrall/riffer-rig/issues/220)) ([e43d3ac](https://github.com/bottrall/riffer-rig/commit/e43d3ac44678e56016791545ea241779569687c9))
+* reload automatically before each request ([#222](https://github.com/bottrall/riffer-rig/issues/222)) ([fe96aa4](https://github.com/bottrall/riffer-rig/commit/fe96aa4476b0765e58824a8eb59301f0986e397c))
+
 ## [0.9.0](https://github.com/bottrall/riffer-rig/compare/v0.8.0...v0.9.0) (2026-10-04)
 
 

data/README.md

@@ -47,6 +47,8 @@ The model is the first of these that is set: `--model`, `RIFFER_MODEL`, `model`
 | `--tools read,bash`     | only these tools, by identifier ([Tools](docs/TOOLS.md))                    |
 | `--max-steps N`         | stops a turn after `N` model calls                                          |
 | `--no-save`             | does not save this session to the [store](docs/SESSIONS.md)                 |
+| `-c`, `--continue`      | continues the most recent session in this directory ([Sessions](docs/SESSIONS.md#resuming)) |
+| `-r ID`, `--resume ID`  | resumes the session with id `ID` ([Sessions](docs/SESSIONS.md#resuming))    |
 | `-h`, `--help`          | prints the usage                                                            |
 
 `riffer -p` (one prompt, no terminal) and `riffer acp` (an editor's agent over stdio) are reserved: for now each prints the usage and exits with status 2.

data/lib/riffer/rig/cli/flags.rb

@@ -9,12 +9,14 @@ class Riffer::Rig::CLI::Flags
            riffer acp           (not available yet)
   TEXT
 
-  # @dynamic model, extensions, skills, agents_md, tools, max_steps, help, save
+  # @dynamic model, extensions, skills, agents_md, tools, max_steps, help, save, continue, resume
   attr_reader :model #: String?
   attr_reader :extensions, :skills, :agents_md, :help #: bool
   attr_reader :tools #: Array[String]?
   attr_reader :max_steps #: Integer?
   attr_reader :save #: bool
+  attr_reader :continue #: bool
+  attr_reader :resume #: String?
 
   # @rbs argv: Array[String]
   # @rbs return: Riffer::Rig::CLI::Flags | String
@@ -31,6 +33,8 @@ class Riffer::Rig::CLI::Flags
       tools: values[:tools],
       max_steps: values[:'max-steps'],
       save: !values.key?(:'no-save'),
+      continue: values.key?(:continue),
+      resume: values[:resume],
       help: values.key?(:help)
     )
   rescue OptionParser::ParseError => e
@@ -54,6 +58,8 @@ class Riffer::Rig::CLI::Flags
       parser.on('--tools NAME,NAME', Array, 'Only these tools, by identifier')
       parser.on('--max-steps N', Integer, 'Stop a turn after N model calls')
       parser.on('--no-save', 'Do not save this session')
+      parser.on('-c', '--continue', 'Continue the most recent session in this directory')
+      parser.on('-r ID', '--resume ID', String, 'Resume the session with this id')
       parser.on('-h', '--help', 'Show this help')
     end
   end
@@ -66,6 +72,8 @@ class Riffer::Rig::CLI::Flags
   # @rbs tools: Array[String]?
   # @rbs max_steps: Integer?
   # @rbs save: bool
+  # @rbs continue: bool
+  # @rbs resume: String?
   # @rbs help: bool
   # @rbs return: void
   def initialize(
@@ -76,6 +84,8 @@ class Riffer::Rig::CLI::Flags
     tools: nil,
     max_steps: nil,
     save: true,
+    continue: false,
+    resume: nil,
     help: false
   )
     @model = model
@@ -85,6 +95,8 @@ class Riffer::Rig::CLI::Flags
     @tools = tools&.freeze
     @max_steps = max_steps
     @save = save
+    @continue = continue
+    @resume = resume
     @help = help
     freeze
   end

data/lib/riffer/rig/cli.rb

@@ -52,22 +52,53 @@ module Riffer::Rig::CLI
       version: Riffer::Rig::VERSION,
       no_color: env.is_a?(Riffer::Rig::Env) && env.no_color
     ).run do |host|
-      Riffer::Rig::Loader.runtime(
+      loader = Riffer::Rig::Loader.new(
         cwd: cwd,
         host: host,
         env: env,
         home: home,
-        model: flags.model,
-        extensions: flags.extensions,
-        skills: flags.skills,
-        agents_md: flags.agents_md,
-        tools: flags.tools,
-        max_steps: flags.max_steps,
         store: flags.save ? Riffer::Rig::Stores::JSONL.new : nil
       )
+      resumed(flags, host, loader) || build(loader, flags)
     end
   end
 
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs return: Riffer::Rig::Runtime?
+  def resumed(flags, host, loader)
+    if flags.resume
+      started = loader.resume(flags.resume, **keywords(flags))
+      host.notify("No saved session #{flags.resume}.") unless started
+      started
+    elsif flags.continue
+      started = loader.continue(**keywords(flags))
+      host.notify('No saved session in this directory.') unless started
+      started
+    end
+  end
+
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs return: Riffer::Rig::Runtime
+  def build(loader, flags)
+    loader.runtime(**keywords(flags))
+  end
+
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs return: Hash[Symbol, untyped]
+  def keywords(flags)
+    {
+      model: flags.model,
+      extensions: flags.extensions,
+      skills: flags.skills,
+      agents_md: flags.agents_md,
+      tools: flags.tools,
+      max_steps: flags.max_steps
+    }
+  end
+
   # @rbs name: String
   # @rbs error: IO
   # @rbs return: Integer

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,99 @@ 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| store.updated(header.fetch(:id)) || Time.at(0) }
+    return nil unless latest
+
+    id = latest.fetch(:id) #: String
+    resume(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[Hash[Symbol, untyped]]
+  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 +249,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 +278,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 +563,29 @@ class Riffer::Rig::Loader
     File.join(@home, '.riffer', 'settings.json')
   end
 
+  # @rbs entries: Array[Hash[Symbol, untyped]]
+  # @rbs id: String
+  # @rbs return: Hash[Symbol, untyped]
+  def snapshot_of(entries, id)
+    models = entries.select { |entry| entry[:type] == 'model' }
+    {
+      id: id,
+      messages: entries.select { |entry| entry[:type] == 'message' }.map { |entry| entry.fetch(:message) },
+      model: models.last&.fetch(:model),
+      skills: entries.select { |entry| entry[:type] == 'skill' }.map { |entry| entry.fetch(:skill) }
+    }
+  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/jsonl.rb

@@ -35,10 +35,23 @@ class Riffer::Rig::Stores::JSONL
   # @rbs cwd: String?
   # @rbs return: Array[Hash[Symbol, untyped]]
   def list(cwd: nil)
-    headers = Dir.glob(File.join(root, '*', '*.jsonl')).filter_map { |path| header_of(path) }
+    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
 
+  # A session's last update is its file's mtime: appends are the only writes.
+  # @rbs id: String
+  # @rbs return: Time?
+  def updated(id)
+    path = find(id)
+    path ? File.mtime(path) : nil
+  end
+
   # @rbs id: String
   # @rbs return: void
   def delete(id)

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

@@ -6,6 +6,7 @@ class Riffer::Rig::Stores::Recorder
   EXTENSION_NAME = 'session-store' #: String
 
   # @rbs @store: Riffer::Rig::Stores::_Store
+  # @rbs @resumed: bool
   # @rbs @runtime: Riffer::Rig::Runtime?
   # @rbs @header_written: bool
   # @rbs @pending: Array[Hash[Symbol, untyped]]
@@ -14,11 +15,15 @@ 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.
+  # 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 return: void
-  def initialize(store:)
+  def initialize(store:, resumed: false)
     @store = store
+    @resumed = resumed
     @runtime = nil
     @header_written = false
     @pending = []
@@ -84,7 +89,7 @@ class Riffer::Rig::Stores::Recorder
   # @rbs return: void
   def write_header
     @header_written = true
-    @store.append(runtime.id, header_entry)
+    @store.append(runtime.id, header_entry) unless @resumed
     @pending.each { |entry| @store.append(runtime.id, entry) }
     @pending.clear
   end

data/lib/riffer/rig/version.rb

@@ -2,6 +2,6 @@
 
 module Riffer
   module Rig
-    VERSION = '0.9.0'
+    VERSION = '0.10.0'
   end
 end

data/sig/generated/riffer/rig/cli/flags.rbs

@@ -3,7 +3,7 @@
 class Riffer::Rig::CLI::Flags
   BANNER: String
 
-  # @dynamic model, extensions, skills, agents_md, tools, max_steps, help, save
+  # @dynamic model, extensions, skills, agents_md, tools, max_steps, help, save, continue, resume
   attr_reader model: String?
 
   attr_reader extensions: bool
@@ -20,6 +20,10 @@ class Riffer::Rig::CLI::Flags
 
   attr_reader save: bool
 
+  attr_reader continue: bool
+
+  attr_reader resume: String?
+
   # @rbs argv: Array[String]
   # @rbs return: Riffer::Rig::CLI::Flags | String
   def self.parse: (Array[String] argv) -> (Riffer::Rig::CLI::Flags | String)
@@ -37,7 +41,9 @@ class Riffer::Rig::CLI::Flags
   # @rbs tools: Array[String]?
   # @rbs max_steps: Integer?
   # @rbs save: bool
+  # @rbs continue: bool
+  # @rbs resume: String?
   # @rbs help: bool
   # @rbs return: void
-  def initialize: (?model: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?, ?save: bool, ?help: bool) -> void
+  def initialize: (?model: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?, ?save: bool, ?continue: bool, ?resume: String?, ?help: bool) -> void
 end

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

@@ -28,6 +28,21 @@ module Riffer::Rig::CLI
   # @rbs return: Integer
   def terminal: (Riffer::Rig::CLI::Flags flags, input: IO, output: IO, env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid, cwd: String, home: String) -> Integer
 
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs return: Riffer::Rig::Runtime?
+  def resumed: (Riffer::Rig::CLI::Flags flags, Riffer::Rig::Hosts::_Host host, Riffer::Rig::Loader loader) -> Riffer::Rig::Runtime?
+
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs return: Riffer::Rig::Runtime
+  def build: (Riffer::Rig::Loader loader, Riffer::Rig::CLI::Flags flags) -> Riffer::Rig::Runtime
+
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs return: Hash[Symbol, untyped]
+  def keywords: (Riffer::Rig::CLI::Flags flags) -> Hash[Symbol, untyped]
+
   # @rbs name: String
   # @rbs error: IO
   # @rbs return: Integer

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

@@ -10,6 +10,8 @@ class Riffer::Rig::Loader
 
   EXTENSION_FEATURE: String
 
+  @reload_mode: :auto | :manual | nil
+
   @file_state: Hash[String, Time?]?
 
   @gem_extensions: Array[Riffer::Rig::Extension]
@@ -47,8 +49,10 @@ 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: String, host: Riffer::Rig::Hosts::_Host, ?env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid, ?home: String, ?riffer_config: Riffer::Config, ?model: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?, ?store: Riffer::Rig::Stores::_Store | nil) -> Riffer::Rig::Runtime
+  def self.runtime: (cwd: String, host: Riffer::Rig::Hosts::_Host, ?env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid, ?home: String, ?riffer_config: Riffer::Config, ?model: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?, ?store: Riffer::Rig::Stores::_Store | nil, ?reload: :auto | :manual | nil, ?snapshot: Hash[Symbol, untyped]?) -> Riffer::Rig::Runtime
 
   # @rbs cwd: String
   # @rbs host: Riffer::Rig::Hosts::_Host
@@ -65,15 +69,46 @@ 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: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?) -> Riffer::Rig::Runtime
+  def runtime: (?model: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?, ?reload: :auto | :manual | nil, ?snapshot: Hash[Symbol, untyped]?) -> Riffer::Rig::Runtime
+
+  # @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: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?) -> Riffer::Rig::Runtime?
+
+  # 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: (String id, ?model: String?, ?extensions: bool, ?skills: bool, ?agents_md: bool, ?tools: Array[String]?, ?max_steps: Integer?) -> Riffer::Rig::Runtime?
+
+  # @rbs all: bool
+  # @rbs return: Array[Hash[Symbol, untyped]]
+  def list: (?all: bool) -> Array[Hash[Symbol, untyped]]
+
+  # @rbs id: String
+  # @rbs return: void
+  def delete: (String id) -> void
 
   # 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)
@@ -81,11 +116,28 @@ 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: (Riffer::Rig::Settings::Document document) -> (:auto | :manual)
+
+  # @rbs return: bool
+  def manual_reload?: () -> bool
+
+  # 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: (Riffer::Rig::Runtime runtime) -> void
+
   # @rbs return: Hash[Symbol, untyped]
   def merged_settings: () -> Hash[Symbol, untyped]
 
-  # 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: (Riffer::Rig::Runtime runtime) -> (Riffer::Rig::Runtime | String)
@@ -206,9 +258,15 @@ class Riffer::Rig::Loader
   # @rbs return: String
   def home_settings_path: () -> String
 
+  # @rbs entries: Array[Hash[Symbol, untyped]]
+  # @rbs id: String
+  # @rbs return: Hash[Symbol, untyped]
+  def snapshot_of: (Array[Hash[Symbol, untyped]] entries, String id) -> Hash[Symbol, untyped]
+
   # 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: (Riffer::Rig::Settings::Document document) -> Riffer::Rig::Stores::Recorder?
+  def recorder_for: (Riffer::Rig::Settings::Document document, resumed: bool) -> Riffer::Rig::Stores::Recorder?
 end

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

@@ -26,6 +26,8 @@ class Riffer::Rig::Runtime
   # tests and embedders can exercise the switches.
   NATIVE_TOOLS_BY_PROVIDER: Hash[Symbol, Hash[Symbol, bool]]
 
+  @model_observers: Array[^(String) -> void]
+
   @message_observers: Array[^(Riffer::Messages::Base) -> void]
 
   @model_override: String?
@@ -54,8 +56,6 @@ class Riffer::Rig::Runtime
 
   @agent: Riffer::Agent
 
-  @model_observers: Array[^(String) -> void]
-
   @prompts: Hash[Symbol, ^(Riffer::Rig::Runtime) -> String?]
 
   @commands: Hash[String, Riffer::Rig::Command]
@@ -82,6 +82,8 @@ class Riffer::Rig::Runtime
 
   @native_tools: Hash[Symbol, untyped]
 
+  @reload_check: (^(::Riffer::Rig::Runtime) -> void)?
+
   # @dynamic agent, credentials, cwd, host, id, settings, declared_settings
   attr_reader agent: Riffer::Agent
 
@@ -134,6 +136,13 @@ class Riffer::Rig::Runtime
   # @rbs return: nil
   def install_command: (Riffer::Rig::Command command) -> nil
 
+  # 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: (^(::Riffer::Rig::Runtime) -> void check) -> nil
+
   # @rbs name: String
   # @rbs args: String
   # @rbs &block: ?(::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event) -> void

data/sig/generated/riffer/rig/settings/document.rbs

@@ -1,7 +1,7 @@
 # Generated from lib/riffer/rig/settings/document.rb with RBS::Inline
 
 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?
@@ -18,6 +18,8 @@ class Riffer::Rig::Settings::Document
 
   attr_reader save: bool
 
+  attr_reader reload: :auto | :manual
+
   # @rbs source: Hash[Symbol, untyped]
   # @rbs return: void
   def initialize: (Hash[Symbol, untyped] source) -> void

data/sig/generated/riffer/rig/stores/jsonl.rbs

@@ -3,10 +3,10 @@
 class Riffer::Rig::Stores::JSONL
   HEADER_VERSION: Integer
 
-  @home: String
-
   @paths: Hash[String, String]
 
+  @home: String
+
   # @rbs home: String
   # @rbs return: void
   def initialize: (?home: String) -> void
@@ -24,6 +24,11 @@ class Riffer::Rig::Stores::JSONL
   # @rbs return: Array[Hash[Symbol, untyped]]
   def list: (?cwd: String?) -> Array[Hash[Symbol, untyped]]
 
+  # A session's last update is its file's mtime: appends are the only writes.
+  # @rbs id: String
+  # @rbs return: Time?
+  def updated: (String id) -> Time?
+
   # @rbs id: String
   # @rbs return: void
   def delete: (String id) -> void

data/sig/generated/riffer/rig/stores/recorder.rbs

@@ -11,15 +11,20 @@ class Riffer::Rig::Stores::Recorder
 
   @runtime: Riffer::Rig::Runtime?
 
+  @resumed: bool
+
   @store: Riffer::Rig::Stores::_Store
 
   # 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.
+  # 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 return: void
-  def initialize: (store: Riffer::Rig::Stores::_Store) -> void
+  def initialize: (store: Riffer::Rig::Stores::_Store, ?resumed: bool) -> void
 
   # @rbs runtime: Riffer::Rig::Runtime
   # @rbs return: void

data/sig/manual/riffer/rig/stores.rbs

@@ -6,6 +6,7 @@ module Riffer::Rig::Stores
     def append: (String id, Hash[Symbol, untyped] entry) -> void
     def read: (String id) -> Array[Hash[Symbol, untyped]]
     def list: (?cwd: String?) -> Array[Hash[Symbol, untyped]]
+    def updated: (String id) -> Time?
     def delete: (String id) -> void
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer-rig
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Jake Bottrall