riffer-rig 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fe0ea5d0af46d44401a20ba9880877d1f631d4131de70452256a5def7d206aa
-  data.tar.gz: '0108f44f3cd248417bee1320ef14921cf75d8018784b103ebf85d676f941cd79'
+  metadata.gz: 613c884d96e252c8793e442b39cf843d5c91438fc7d6ae6bc963536cb978de09
+  data.tar.gz: f4e2596e6c67e87f19011afa452c207f5f6e8b0394673c58e1ae22a57e2f2269
 SHA512:
-  metadata.gz: 761434ca55b8f51971328b39ad0dfa02d4a89e21c41f03b1dfb55778c09cac14f4d3328799e8a6e1b25027f9d30a953d3278f4a0264a0ae558e6f56ef577c779
-  data.tar.gz: f9e88b15b40d562553f4b0b871a1b992c0da8c6b883159561be132e3b74312b7fce5d31b18391db99366e7bc6a4d0070639efce9abe7b454e572d9d4e7acc659
+  metadata.gz: 1d1b670b735b7d06b7b88d38c305e09018db879ca5ffe1a65a89f1424ae25b9d324b234bb3d38e89889305f85cb1f97822d2a76fba083f83e76f256cec6de331
+  data.tar.gz: 77c745faeb40661a33801885cee13d7811b05c9e557e5798a5ebb6233aef18e7c74e194f4fc9b4347cac4ff0b8182ca8c42b2e70fda71a051ee13849dbdea8f3

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.14.0](https://github.com/bottrall/riffer-rig/compare/v0.13.0...v0.14.0) (2026-10-18)
+
+
+### Features
+
+* **headless:** print the session id on stderr ([#556](https://github.com/bottrall/riffer-rig/issues/556)) ([2816938](https://github.com/bottrall/riffer-rig/commit/2816938f66d32ccf557d83a33e40300e68a68032))
+* make reasoning effort configurable like the model ([#553](https://github.com/bottrall/riffer-rig/issues/553)) ([330f190](https://github.com/bottrall/riffer-rig/commit/330f190244353ed5e967b0f29d574c2741d92dba))
+* **terminal:** keep the status bar filled between turns ([#555](https://github.com/bottrall/riffer-rig/issues/555)) ([e0918ec](https://github.com/bottrall/riffer-rig/commit/e0918ecd050519cf06d0593221b3b50e0e1a6778))
+* **terminal:** type a multiline prompt ([#557](https://github.com/bottrall/riffer-rig/issues/557)) ([a55091c](https://github.com/bottrall/riffer-rig/commit/a55091c091e4df4ad6c63a71d7dd16d1de98e835))
+* upgrade riffer to 0.53.0 and adopt the model catalog ([#552](https://github.com/bottrall/riffer-rig/issues/552)) ([70b129b](https://github.com/bottrall/riffer-rig/commit/70b129b27a4d03188ef7831937874d7bb73cea08))
+
+
+### Bug Fixes
+
+* stop models from polling background bash jobs ([#559](https://github.com/bottrall/riffer-rig/issues/559)) ([57ad0ba](https://github.com/bottrall/riffer-rig/commit/57ad0ba259d0ebd71f4cc4178172364f39a62782))
+* **terminal:** draw the banner and the input row together ([#549](https://github.com/bottrall/riffer-rig/issues/549)) ([e847277](https://github.com/bottrall/riffer-rig/commit/e847277af41ebd824dd115105d7d40e9af236da4))
+
 ## [0.13.0](https://github.com/bottrall/riffer-rig/compare/v0.12.0...v0.13.0) (2026-10-17)
 
 

data/README.md

@@ -34,13 +34,14 @@ riffer
 
 The first run asks which model to use, as `provider/name` (for example `anthropic/claude-sonnet-4-6`), and saves the answer as `model` in `~/.riffer/settings.json`; it then asks for any missing credential ([Authentication](#authentication)). After that, `riffer` opens straight into the prompt. [Getting started](docs/GETTING_STARTED.md) walks through a first session.
 
-The model is the first of these that is set: `--model`, `RIFFER_MODEL`, `model` in `<cwd>/.riffer/settings.json`, then in `~/.riffer/settings.json` ([Configuration](docs/CONFIGURATION.md#model)).
+The model is the first of these that is set: `--model`, `RIFFER_MODEL`, `model` in `<cwd>/.riffer/settings.json`, then in `~/.riffer/settings.json` ([Configuration](docs/CONFIGURATION.md#model)). The reasoning effort resolves the same way: `--reasoning`, `RIFFER_REASONING`, then `reasoning` in the settings ([Configuration](docs/CONFIGURATION.md#reasoning)).
 
 ### Flags
 
 | Flag                    | Effect                                                                     |
 | ----------------------- | -------------------------------------------------------------------------- |
 | `--model provider/name` | the model for this session, over `RIFFER_MODEL` and the settings            |
+| `--reasoning LEVEL`     | the reasoning effort for this session, over `RIFFER_REASONING` and the settings |
 | `--no-extensions`       | skips the [`rig.rb` files](docs/EXTENSIONS.md#the-rigrb-files) and gem autoload; the bundle still loads |
 | `--no-skills`           | leaves out [Agent Skills](docs/SKILLS.md)                                   |
 | `--no-agents-md`        | leaves out the [AGENTS.md](docs/INSTRUCTIONS.md#agentsmd) instructions      |
@@ -70,16 +71,20 @@ The exit code says how the turn ended: `0` finished, `1` runtime error, `2` usag
 
 ### In the session
 
-Type a prompt and press Enter. While the turn runs, the status line under the input shows its time, steps, tool calls, tokens and cost, and Ctrl-T peeks at what the model is writing; the reply is printed when the turn ends, followed by a stat line (`N steps · mm:ss · ↑in · ↓out · session N tok`, plus the turn's cost and the session's when the model is [priced](docs/CONFIGURATION.md#models)). The input line stays open throughout: a message sent during a turn is queued and runs when the turn ends. [Terminal](docs/TERMINAL.md) has every key.
+Type a prompt and press Enter. While the turn runs, the status line under the input shows its time, steps, tool calls, tokens and cost, and Ctrl-T peeks at what the model is writing; the reply is printed when the turn ends, followed by a stat line (`N steps · mm:ss · ↑in · ↓out · session N tok`, plus the turn's cost and the session's when the model is [priced](docs/CONFIGURATION.md#catalog_files)). The input line stays open throughout: a message sent during a turn is queued and runs when the turn ends. [Terminal](docs/TERMINAL.md) has every key.
 
 - Ctrl-C during a turn cancels it. Ctrl-C with no turn running asks for a second one, which exits.
 - `/exit` or `/quit` ends the session, as does Ctrl-D on an empty line.
-- `/help` lists the session's slash commands. `/resume [--all]`, `/new`, `/cost`, `/trace`, `/skill:<name>` and the others are described in [Terminal](docs/TERMINAL.md#commands); `/model` is covered [below](#switching-the-model).
+- `/help` lists the session's slash commands. `/resume [--all]`, `/new`, `/cost`, `/trace`, `/skill:<name>` and the others are described in [Terminal](docs/TERMINAL.md#commands); `/model` is covered [below](#switching-the-model), and `/reasoning` works the same way for the reasoning effort.
 
 ### Switching the model
 
 `/model provider/name` switches the model for the current session only, keeping the conversation so far, and confirms it in one line: `/model openai/gpt-5` prints `Model switched to openai/gpt-5`. The provider prefix is required: a bare name such as `/model sonnet` is rejected with the list of providers. `/model` alone shows the model in use. Switching runs the same setup for the new provider as startup does: its SDK gem is offered for install (or refused with the exact Gemfile line), and missing credentials are resolved — you are prompted for them when the host can ask, and the values apply to the running session immediately. The switch is refused with one error when the host cannot supply what is missing, and the model is left unchanged. `/model --save` writes the model in effect to the home `settings.json`, so new sessions start with it; `/model provider/name --save` switches and saves in one step, printing `Model switched to openai/gpt-5 and saved to ~/.riffer/settings.json` (a bare `/model --save` prints `Saved openai/gpt-5 to ~/.riffer/settings.json`), and a refused switch saves nothing ([Configuration](docs/CONFIGURATION.md#model)).
 
+### Switching the reasoning level
+
+`/reasoning level` switches the reasoning effort for the current session only, keeping the conversation so far: `/reasoning high` prints `Reasoning switched to high`, `/reasoning off` turns reasoning off, and `/reasoning` alone shows the level in effect. A level riffer does not accept is rejected naming the levels it accepts. `/reasoning --save` writes the level in effect to the home `settings.json` (`/reasoning high --save` switches and saves in one step), and a home file that no longer parses is reported instead of written. The switch survives a resume, and a `--reasoning` chosen for the run wins over it for that run only ([Configuration](docs/CONFIGURATION.md#reasoning)).
+
 ## Authentication
 
 `riffer-rig` talks to the provider named by the model's prefix — `anthropic/claude-sonnet-4-6` means Anthropic. Provide that provider's credentials in either of two ways:
@@ -115,18 +120,19 @@ Inside a session, `/auth` lists every provider with where its secret comes from
 
 Settings live in two scopes, both optional: `~/.riffer/settings.json` for every project, and `<cwd>/.riffer/settings.json` for one project, merged key by key with the project winning ([Configuration](docs/CONFIGURATION.md)). Every core key is optional:
 
-| Key          | What it sets                                                                     |
-| ------------ | -------------------------------------------------------------------------------- |
-| `model`      | the model new sessions start with, as `provider/name`                            |
-| `reasoning`  | the reasoning effort, translated to the provider's own parameter                 |
-| `models`     | prices each model in USD per million tokens                                      |
-| `providers`  | non-secret provider fields such as an endpoint or region (home file only)        |
-| `extensions` | `disabled` — bundled extensions to leave out; `autoload` — gem extension autoload |
-| `reload`     | `"auto"` (default) or `"manual"` — the hot-reload trigger                        |
-| `sessions`   | `save: false` stops saving sessions to the store                                 |
-| `tools`      | the provider-native tool switches (`native`), off by default                     |
+| Key            | What it sets                                                                     |
+| -------------- | -------------------------------------------------------------------------------- |
+| `model`        | the model new sessions start with, as `provider/name`                            |
+| `reasoning`    | the reasoning effort, which riffer translates to the provider's own parameter    |
+| `catalog_files`| the model catalog JSON files holding pricing and reasoning maps                  |
+| `providers`    | non-secret provider fields such as an endpoint or region (home file only)        |
+| `extensions`   | `disabled` — bundled extensions to leave out; `autoload` — gem extension autoload |
+| `reload`       | `"auto"` (default) or `"manual"` — the hot-reload trigger                        |
+| `sessions`     | `save: false` stops saving sessions to the store                                 |
+| `tools`        | the provider-native tool switches (`native`), off by default                     |
 
 - `RIFFER_MODEL` — the model for this run as `provider/name`, winning over the `model` setting. A bare name such as `sonnet` is rejected with the list of providers.
+- `RIFFER_REASONING` — the reasoning effort for this run, winning over the `reasoning` setting; a level riffer does not accept is rejected naming the levels it accepts.
 - `AGENTS.md` — `~/.riffer/AGENTS.md` and an `AGENTS.md` in the current working directory or any directory above it are re-read every turn as instructions that take precedence over the default norms ([Instructions](docs/INSTRUCTIONS.md#agentsmd)).
 - Skills — Agent Skills in `.agents/skills/` from the working directory up to the repository root, and in `~/.agents/skills/`, are offered to the model, and `/skill:<name> [text]` runs one ([Skills](docs/SKILLS.md)).
 - MCP servers — declared under the `mcp` key in either settings file and registered with the Runtime ([MCP](docs/MCP.md)).

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

@@ -9,9 +9,10 @@ class Riffer::Rig::CLI::Flags
            riffer acp           serve Runtimes as an ACP agent over stdio
   TEXT
 
-  # @dynamic model, extensions, skills, agents_md, tools, max_steps, help, version
+  # @dynamic model, reasoning, extensions, skills, agents_md, tools, max_steps, help, version
   # @dynamic save, verbose, json, job_idle_timeout, headless, prompt, continue, resume
   attr_reader :model #: String?
+  attr_reader :reasoning #: String?
   attr_reader :extensions, :skills, :agents_md, :help, :version, :verbose, :json, :headless #: bool
   attr_reader :tools #: Array[String]?
   attr_reader :max_steps #: Integer?
@@ -47,6 +48,7 @@ class Riffer::Rig::CLI::Flags
   def to_options
     Riffer::Rig::Loader::Options.new(
       model: model,
+      reasoning: reasoning,
       extensions: extensions,
       skills: skills,
       agents_md: agents_md,
@@ -61,6 +63,7 @@ class Riffer::Rig::CLI::Flags
       parser.banner = BANNER
       parser.separator('')
       parser.on('--model PROVIDER/NAME', String, 'Model for this session, over RIFFER_MODEL and settings')
+      parser.on('--reasoning LEVEL', String, 'Reasoning level for this session, over RIFFER_REASONING and settings')
       parser.on('--no-extensions', 'Skip extension files and autoload; the bundle still loads')
       parser.on('--no-skills', 'Leave out Agent Skills')
       parser.on('--no-agents-md', 'Leave out AGENTS.md instructions')
@@ -94,6 +97,7 @@ class Riffer::Rig::CLI::Flags
   def self.assemble(values, prompt)
     new(
       model: values[:model],
+      reasoning: values[:reasoning],
       extensions: !values.key?(:'no-extensions'),
       skills: !values.key?(:'no-skills'),
       agents_md: !values.key?(:'no-agents-md'),
@@ -114,6 +118,7 @@ class Riffer::Rig::CLI::Flags
   private_class_method :assemble
 
   # @rbs model: String?
+  # @rbs reasoning: String?
   # @rbs extensions: bool
   # @rbs skills: bool
   # @rbs agents_md: bool
@@ -132,6 +137,7 @@ class Riffer::Rig::CLI::Flags
   # @rbs return: void
   def initialize(
     model: nil,
+    reasoning: nil,
     extensions: true,
     skills: true,
     agents_md: true,
@@ -149,6 +155,7 @@ class Riffer::Rig::CLI::Flags
     version: false
   )
     @model = model
+    @reasoning = reasoning
     @extensions = extensions
     @skills = skills
     @agents_md = agents_md

data/lib/riffer/rig/commands/reasoning.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Commands::Reasoning
+  extend self
+
+  SAVE = '--save' #: String
+  SAVED_TO = '~/.riffer/settings.json' #: String
+  DEFAULT = 'default' #: String
+
+  # @rbs return: Riffer::Rig::Command
+  def command
+    Riffer::Rig::Command.new(
+      'reasoning',
+      description: 'Switch the reasoning level for this session: /reasoning high, /reasoning --save',
+      extension: :core
+    ) { |ctx| run(ctx) }
+  end
+
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs return: void
+  def run(ctx)
+    words = ctx.args.split
+    save = words.delete(SAVE)
+    level = words.join(' ')
+
+    if level.empty?
+      current = ctx.runtime.reasoning
+      return ctx.say("Reasoning: #{current || DEFAULT}") unless save
+      return ctx.say('No reasoning level is in effect to save') unless current
+
+      refusal = Riffer::Rig::Settings::File.store_reasoning(current)
+      return ctx.host.notify(refusal, level: :error) if refusal
+
+      return ctx.say("Saved #{current} to #{SAVED_TO}")
+    end
+
+    rejection = Riffer::Rig::Settings::ModelOptions.reasoning_rejection(level)
+    return ctx.say(rejection) if rejection
+
+    ctx.runtime.reasoning = level
+    refusal = Riffer::Rig::Settings::File.store_reasoning(level) if save
+    ctx.host.notify(refusal, level: :error) if refusal
+    saved = save && !refusal
+    ctx.say(saved ? "Reasoning switched to #{level} and saved to #{SAVED_TO}" : "Reasoning switched to #{level}")
+  end
+end

data/lib/riffer/rig/env.rb

@@ -3,9 +3,10 @@
 class Riffer::Rig::Env
   # @rbs @source: Hash[String, String]
 
-  # @dynamic no_color, model
+  # @dynamic no_color, model, reasoning
   attr_reader :no_color #: bool
   attr_reader :model #: String?
+  attr_reader :reasoning #: String?
 
   # @rbs source: Hash[String, String]
   # @rbs return: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
@@ -22,6 +23,7 @@ class Riffer::Rig::Env
     @source = source.freeze
     @no_color = @source.key?('NO_COLOR')
     @model = self['RIFFER_MODEL']
+    @reasoning = self['RIFFER_REASONING']
     freeze
   end
 

data/lib/riffer/rig/headless.rb

@@ -203,6 +203,8 @@ class Riffer::Rig::Headless
     return @output.write(Ndjson.line(event)) if @json
 
     case event
+    when Riffer::Rig::Events::SessionStart
+      @error.puts("session #{event.id}")
     when Riffer::StreamEvents::TextDelta
       write_text(event.content)
       @streamed_text = true

data/lib/riffer/rig/loader/options.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Loader::Options
-  # @dynamic model, extensions, skills, agents_md, tools, max_steps
+  # @dynamic model, reasoning, extensions, skills, agents_md, tools, max_steps
   attr_reader :model #: String?
+  attr_reader :reasoning #: String?
   attr_reader :extensions #: bool
   attr_reader :skills #: bool
   attr_reader :agents_md #: bool
@@ -10,6 +11,7 @@ class Riffer::Rig::Loader::Options
   attr_reader :max_steps #: Integer?
 
   # @rbs model: String?
+  # @rbs reasoning: String?
   # @rbs extensions: bool
   # @rbs skills: bool
   # @rbs agents_md: bool
@@ -18,6 +20,7 @@ class Riffer::Rig::Loader::Options
   # @rbs return: void
   def initialize(
     model: nil,
+    reasoning: nil,
     extensions: true,
     skills: true,
     agents_md: true,
@@ -25,6 +28,7 @@ class Riffer::Rig::Loader::Options
     max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
   )
     @model = model
+    @reasoning = reasoning
     @extensions = extensions
     @skills = skills
     @agents_md = agents_md

data/lib/riffer/rig/loader.rb

@@ -85,11 +85,13 @@ class Riffer::Rig::Loader
 
     document = Riffer::Rig::Settings::Document.new(settings)
     selected = select_model(options.model || @env.model || document.model)
+    check_reasoning(options)
     provider = Riffer::Rig::Settings::ModelOptions.provider_for(selected).to_s
     ensure_sdk(provider)
     credentials = install_credentials(provider)
     raise ConfigurationError, credentials if credentials.is_a?(String)
 
+    @riffer_config.catalog_files = document.catalog_files
     @extensions_enabled = options.extensions
     @extra_extensions = extra_extensions
     @reload_mode = reload
@@ -102,6 +104,9 @@ class Riffer::Rig::Loader
     @recorder_extensions = recorder ? [Riffer::Rig::Stores::Recorder.extension(recorder)] : []
     loaded += @recorder_extensions
 
+    snapshot = snapshot_without_forced(snapshot, options)
+    reasoning = forced_reasoning(options, snapshot)
+
     built = Riffer::Rig::Runtime.new(
       selected,
       extensions: loaded,
@@ -113,11 +118,11 @@ class Riffer::Rig::Loader
       credentials: { provider.to_sym => credentials },
       env: @env,
       auth_path: home_auth_path,
-      pricing: document.models,
+      reasoning: reasoning || settings_reasoning(document),
       riffer_config: @riffer_config,
-      model_options: Riffer::Rig::Settings::ModelOptions.model_options(selected, document.reasoning),
+      model_options: Riffer::Rig::Settings::ModelOptions.model_options(selected),
       native_tools: document.native_tools,
-      snapshot: options.model ? snapshot&.merge(model: nil) : snapshot
+      snapshot: snapshot
     )
     built.install_command(Riffer::Rig::Commands::Reload.command(self))
     store = @store
@@ -370,6 +375,55 @@ class Riffer::Rig::Loader
     File.join(@home, '.riffer', 'auth.json')
   end
 
+  # A reasoning level from the flag or the environment is refused, the way a
+  # bad model string is; one from the settings document or a session's recorded
+  # switch falls back to the model's default instead.
+  # @rbs options: Riffer::Rig::Loader::Options
+  # @rbs return: void
+  def check_reasoning(options)
+    forced = options.reasoning || @env.reasoning
+    return unless forced
+
+    rejection = Riffer::Rig::Settings::ModelOptions.reasoning_rejection(forced)
+    return unless rejection
+
+    raise ConfigurationError, options.reasoning ? rejection : "RIFFER_REASONING: #{rejection}"
+  end
+
+  # The reasoning in effect for the build, over the settings document: the flag,
+  # then the session's recorded switch, then RIFFER_REASONING.
+  # @rbs options: Riffer::Rig::Loader::Options
+  # @rbs snapshot: Hash[Symbol, untyped]?
+  # @rbs return: String?
+  def forced_reasoning(options, snapshot)
+    options.reasoning || recorded_reasoning(snapshot) || @env.reasoning
+  end
+
+  # @rbs snapshot: Hash[Symbol, untyped]?
+  # @rbs return: String?
+  def recorded_reasoning(snapshot)
+    saved = snapshot && snapshot[:reasoning]
+    Riffer::Rig::Settings::ModelOptions.reasoning_level(saved) if saved.is_a?(String)
+  end
+
+  # A settings level riffer does not accept silently keeps the model's default.
+  # @rbs document: Riffer::Rig::Settings::Document
+  # @rbs return: String?
+  def settings_reasoning(document)
+    Riffer::Rig::Settings::ModelOptions.reasoning_level(document.reasoning)
+  end
+
+  # A model or reasoning level chosen for the run wins for that run only: it is
+  # not recorded, so a later resume restores the session's own switches.
+  # @rbs snapshot: Hash[Symbol, untyped]?
+  # @rbs options: Riffer::Rig::Loader::Options
+  # @rbs return: Hash[Symbol, untyped]?
+  def snapshot_without_forced(snapshot, options)
+    snapshot = snapshot&.merge(model: nil) if options.model
+    snapshot = snapshot&.merge(reasoning: nil) if options.reasoning
+    snapshot
+  end
+
   # The store records unless it was declined with store: nil or globally with
   # "sessions": {"save": false}.
   # @rbs document: Riffer::Rig::Settings::Document

data/lib/riffer/rig/registrar.rb

@@ -3,7 +3,9 @@
 class Riffer::Rig::Registrar
   class NameCollisionError < StandardError; end
 
-  CORE_SETTINGS_KEYS = %w[model reasoning models reload extensions sessions providers tools].freeze #: Array[String]
+  CORE_SETTINGS_KEYS = %w[
+    model reasoning catalog_files reload extensions sessions providers tools
+  ].freeze #: Array[String]
 
   EVENTS = %i[
     session_start session_end

data/lib/riffer/rig/runtime/snapshot.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Runtime::Snapshot
-  # @dynamic id, messages, model, skills
+  # @dynamic id, messages, model, reasoning, skills
   attr_reader :id #: String
   attr_reader :messages #: Array[Riffer::Messages::Base]
   attr_reader :model #: String?
+  attr_reader :reasoning #: String?
   attr_reader :skills #: Array[String]
 
   # @rbs hash: Hash[Symbol, untyped]
@@ -17,6 +18,7 @@ class Riffer::Rig::Runtime::Snapshot
       # a Session.from_h could also heal orphaned tool calls on load.
       messages: hash.fetch(:messages).map { |stored| message(stored) },
       model: hash.fetch(:model),
+      reasoning: hash[:reasoning].is_a?(String) ? hash[:reasoning] : nil,
       skills: hash.fetch(:skills)
     )
   end
@@ -34,19 +36,21 @@ class Riffer::Rig::Runtime::Snapshot
   # @rbs id: String
   # @rbs messages: Array[Riffer::Messages::Base]
   # @rbs model: String?
+  # @rbs reasoning: String?
   # @rbs skills: Array[String]
   # @rbs return: void
-  def initialize(id:, messages:, model:, skills:)
+  def initialize(id:, messages:, model:, skills:, reasoning: nil)
     @id = id
     @messages = messages
     @model = model
+    @reasoning = reasoning
     @skills = skills
     freeze
   end
 
   # @rbs return: Hash[Symbol, untyped]
   def to_h
-    { id: @id, messages: @messages.map(&:to_h), model: @model, skills: @skills }
+    { id: @id, messages: @messages.map(&:to_h), model: @model, reasoning: @reasoning, skills: @skills }
   end
 
   # @rbs return: Riffer::Agent::Session

data/lib/riffer/rig/runtime.rb

@@ -61,8 +61,10 @@ class Riffer::Rig::Runtime
   # @rbs @session_start_pending: bool
   # @rbs @session_start_reason: Symbol
   # @rbs @model_override: String?
+  # @rbs @reasoning: String?
   # @rbs @message_observers: Array[^(Riffer::Messages::Base) -> void]
   # @rbs @model_observers: Array[^(String) -> void]
+  # @rbs @reasoning_observers: Array[^(String) -> void]
   # @rbs @system_prompt: Riffer::Rig::Runtime::SystemPrompt
   # @rbs @commands: Hash[String, Riffer::Rig::Command]
   # @rbs @core_commands: Array[Riffer::Rig::Command]
@@ -97,7 +99,7 @@ class Riffer::Rig::Runtime
   # @rbs credentials: Hash[Symbol, Hash[Symbol, String]]
   # @rbs env: Riffer::Rig::Env
   # @rbs auth_path: String
-  # @rbs pricing: Hash[String, Riffer::Rig::Settings::Pricing]
+  # @rbs reasoning: String?
   # @rbs riffer_config: Riffer::Config
   # @rbs mcp_registry: Riffer::Rig::Mcp::_Registry
   # @rbs max_steps: Integer?
@@ -118,7 +120,7 @@ class Riffer::Rig::Runtime
     credentials: {},
     env: Riffer::Rig::Env.new,
     auth_path: Riffer::Rig::Credentials::PATH,
-    pricing: {},
+    reasoning: nil,
     riffer_config: Riffer.config,
     mcp_registry: Riffer::Mcp,
     max_steps: DEFAULT_MAX_STEPS,
@@ -147,7 +149,8 @@ class Riffer::Rig::Runtime
     @session_start_reason = saved ? :restore : :new
     @message_observers = []
     @model_observers = []
-    Riffer::Rig::Settings::Pricing.register(pricing, riffer_config.pricing)
+    @reasoning_observers = []
+    @reasoning = reasoning
     @errors = []
     @tool_allowlist = tools
     @native_tools = native_tools
@@ -257,6 +260,21 @@ class Riffer::Rig::Runtime
     @model_observers.each { |observer| observer.call(model) }
   end
 
+  # @rbs return: String?
+  def reasoning
+    @reasoning || Riffer::Rig::Settings::ModelOptions.reasoning_level(Riffer::Rig::Settings::Document.new(@settings).reasoning)
+  end
+
+  # @rbs level: String
+  # @rbs return: void
+  def reasoning=(level)
+    # Riffer's own validation raises before anything is assigned, so a level it
+    # refuses leaves both the level and the config unchanged.
+    @agent.config.reasoning = level
+    @reasoning = level
+    @reasoning_observers.each { |observer| observer.call(level) }
+  end
+
   # @rbs provider: Symbol
   # @rbs values: Hash[Symbol, String]
   # @rbs return: void
@@ -288,7 +306,11 @@ class Riffer::Rig::Runtime
   # @rbs return: Hash[Symbol, untyped]
   def to_h
     Riffer::Rig::Runtime::Snapshot.new(
-      id: @id, messages: @agent.session.messages, model: @model_override, skills: activated_skills
+      id: @id,
+      messages: @agent.session.messages,
+      model: @model_override,
+      reasoning: @reasoning,
+      skills: activated_skills
     ).to_h
   end
 
@@ -306,6 +328,13 @@ class Riffer::Rig::Runtime
     nil
   end
 
+  # @rbs &block: (String) -> void
+  # @rbs return: nil
+  def on_reasoning_change(&block)
+    @reasoning_observers << block
+    nil
+  end
+
   # @rbs &: (Riffer::Rig::Runtime::JobCompletion) -> void
   # @rbs return: nil
   def on_job_exit(&)
@@ -388,15 +417,15 @@ class Riffer::Rig::Runtime
   end
 
   # The options the settings built for the starting model are provider-shaped
-  # (cache control, per-provider reasoning levels), so a switch re-derives them.
-  # Runs after the successor is built, so a failed build leaves the running
-  # agent's options alone; riffer reads config.model_options per request, so the
-  # swap still reaches the new agent through the shared config.
+  # (anthropic cache control), so a switch re-derives them; the reasoning level
+  # is provider-agnostic and travels on the config. Runs after the successor is
+  # built, so a failed build leaves the running agent's options alone; riffer
+  # reads config.model_options per request, so the swap still reaches the new
+  # agent through the shared config.
   # @rbs model: String
   # @rbs return: void
   def rederive_options(model)
-    reasoning = Riffer::Rig::Settings::Document.new(@settings).reasoning
-    @model_options = Riffer::Rig::Settings::ModelOptions.model_options(model, reasoning).merge(native_options(model))
+    @model_options = Riffer::Rig::Settings::ModelOptions.model_options(model).merge(native_options(model))
     @agent.config.model_options = @model_options
   end
 
@@ -423,6 +452,7 @@ class Riffer::Rig::Runtime
       model: ->(context) { context[:model] },
       model_options: @model_options,
       instructions: @system_prompt.bare,
+      reasoning: @reasoning,
       tools_config: select_tools(registrars.flat_map { |registrar| registrar.tools.to_a }.to_h.values, @tool_allowlist),
       max_steps: max_steps,
       tool_runtime: Riffer::Rig::Runtime::ToolRuntime.new(hooks, emit: ->(event) { emit(event) }, clock: @clock),
@@ -462,6 +492,7 @@ class Riffer::Rig::Runtime
       *@core_commands,
       Riffer::Rig::Commands::Auth.command,
       Riffer::Rig::Commands::Model.command,
+      Riffer::Rig::Commands::Reasoning.command,
       Riffer::Rig::Commands::Cost.command,
       *skills.map { |skill| Riffer::Rig::Commands::Skill.command(skill) },
       *registrars.flat_map { |registrar| registrar.commands.values }
@@ -795,6 +826,7 @@ class Riffer::Rig::Runtime
   # @rbs return: Riffer::Agent
   def restore(snapshot, model, config)
     @model_override = snapshot.restorable_model(@credentials, @host, model)
+    @reasoning = Riffer::Rig::Settings::ModelOptions.reasoning_level(snapshot.reasoning) if snapshot.reasoning
     agent = build_agent(@model_override || model, config, session: snapshot.session)
     agent.context.token_usage = snapshot.usage
     reactivate(agent.context.skills, snapshot.skills)

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Settings::Document
-  # @dynamic model, reasoning, models, providers, disabled, autoload, native_tools, save, reload
+  # @dynamic model, reasoning, catalog_files, providers, disabled, autoload, native_tools, save, reload
   attr_reader :model #: String?
   attr_reader :reasoning #: String?
-  attr_reader :models #: Hash[String, Riffer::Rig::Settings::Pricing]
+  attr_reader :catalog_files #: Array[String]
   attr_reader :providers #: Hash[String, Hash[String, String]]
   attr_reader :disabled #: Array[String]
   attr_reader :autoload #: bool
@@ -17,9 +17,9 @@ class Riffer::Rig::Settings::Document
   def initialize(source)
     @model = source[:model].is_a?(String) ? source[:model] : nil
     @reasoning = source[:reasoning].is_a?(String) ? source[:reasoning] : nil
-    @models = hash_or_empty(source[:models]).filter_map do |name, entry|
-      [name.to_s, Riffer::Rig::Settings::Pricing.from(entry)] if entry.is_a?(Hash)
-    end.to_h.freeze
+    paths = source[:catalog_files]
+    no_files = [] #: Array[String]
+    @catalog_files = paths.is_a?(Array) && paths.all?(String) ? paths.dup.freeze : no_files.freeze
     @providers = hash_or_empty(source[:providers]).filter_map do |identifier, fields|
       if fields.is_a?(Hash)
         [identifier.to_s, fields.select do |_name, value|

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

@@ -24,4 +24,11 @@ module Riffer::Rig::Settings::File
   def store_model(model, path: PATH)
     update(path) { |document| document.merge(model: model) }
   end
+
+  # @rbs level: String
+  # @rbs path: String
+  # @rbs return: String?
+  def store_reasoning(level, path: PATH)
+    update(path) { |document| document.merge(reasoning: level) }
+  end
 end