riffer-rig 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8651df8d201d07a31d22ee2df71fde5942a6219dc405a6e51ab4661f8b910c9d
-  data.tar.gz: 472fe4de066e0a621f61f4ff3da31233b325731709f974ad396973269de36b86
+  metadata.gz: 9b1648704ba63c4826d30aec44988486557c4a2fccc5b3b527fef879fc407cef
+  data.tar.gz: 574c73fcb0f3512f486d6d4c355b69add66d54de82c87ed170c8409821c4b3f1
 SHA512:
-  metadata.gz: 448c573762bcf24c313c5f214ebb8c17988339f74b8a511c1eb9948ef3303a46bec300f7f092a4ba4507a1b03f1dbfa2db43eda464ec78b1254df0455b86886f
-  data.tar.gz: 6c68f67169c7f20ea0ad31f3b2937d4b487b651033f93426d79d6a97ca248a8086bc247cff97688ad7406ea6f30fe9e973c166788f802bbcc99f9a8dad47ab97
+  metadata.gz: 0da1408916c461365dc8d61c07dca3b00ad5f2d22d77e42d036d379ce6231c5cff0ae3ade79a2d8f907439c8e70e33753ae3e5b91786905e5366bf414d0f3521
+  data.tar.gz: 994802e5749d8708313eda67386af949ff4112b9b2275b6687a2078ea2f4332b8147916608cdbf8adb5f90c632bea9b395d5929b9024907f4811e2ecca75eff1

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.17.0](https://github.com/bottrall/riffer-rig/compare/v0.16.0...v0.17.0) (2026-10-24)
+
+
+### Features
+
+* authenticate to Anthropic through the SDK's credential chain ([#606](https://github.com/bottrall/riffer-rig/issues/606)) ([617fdb7](https://github.com/bottrall/riffer-rig/commit/617fdb76f5a54290d2d001b906fce3d530e2cef4))
+* give tools the background job registry as a documented context key ([#579](https://github.com/bottrall/riffer-rig/issues/579)) ([a8e98ac](https://github.com/bottrall/riffer-rig/commit/a8e98acef71b354a2c7601d46366ed0f95b6da37))
+
+
+### Bug Fixes
+
+* --save and /auth honour the injected home ([#596](https://github.com/bottrall/riffer-rig/issues/596)) ([032f26f](https://github.com/bottrall/riffer-rig/commit/032f26f317216f501a9dc71c3d1157ce12bc3893))
+* /auth and /model refusals say how to supply a missing credential ([#597](https://github.com/bottrall/riffer-rig/issues/597)) ([ffe18fe](https://github.com/bottrall/riffer-rig/commit/ffe18fe653db97f4bbb737359f454637bc347778))
+* reasoning in settings reaches the agent ([#577](https://github.com/bottrall/riffer-rig/issues/577)) ([9216429](https://github.com/bottrall/riffer-rig/commit/9216429421be51bb7511e4c8b6eec3bd177e8ba3))
+* reload each Loader-built runtime with its own build's choices ([#598](https://github.com/bottrall/riffer-rig/issues/598)) ([d6b95a6](https://github.com/bottrall/riffer-rig/commit/d6b95a6f1205ecb8ae0221c88bb1012c2ce15e79))
+* **terminal:** keep a capped input inside a short terminal ([#575](https://github.com/bottrall/riffer-rig/issues/575)) ([8b67c2b](https://github.com/bottrall/riffer-rig/commit/8b67c2b9d1ba404ffb12bb42f120e034aae8183b))
+
 ## [0.16.0](https://github.com/bottrall/riffer-rig/compare/v0.15.0...v0.16.0) (2026-10-18)
 
 

data/README.md

@@ -25,14 +25,6 @@ The first run asks for a model as `provider/name` — for example `anthropic/cla
 
 Type a prompt and press Enter. `/help` lists the commands, and [Getting started](docs/GETTING_STARTED.md) walks through a first session.
 
-To run one prompt from a script or CI job:
-
-```bash
-git diff | riffer -p "review this diff"
-```
-
-[Headless](docs/HEADLESS.md) covers exit codes and the NDJSON stream; editors connect over [ACP](docs/ACP.md) with `riffer acp`.
-
 ## Extend it
 
 An extension is a Ruby block in `~/.riffer/rig.rb` (every project) or `.riffer/rig.rb` (one project):
@@ -62,20 +54,13 @@ The guides are at **<https://riffer.bottrall.dev>**, and their sources are in [`
 - [Overview](docs/OVERVIEW.md) — what riffer-rig is and how it fits together
 - [Configuration](docs/CONFIGURATION.md) — settings and where each value comes from
 - [Command line](docs/CLI.md) — every flag
+- [Headless mode](docs/HEADLESS.md) — one prompt from a script or CI job, with exit codes and an NDJSON stream
+- [ACP](docs/ACP.md) — riffer-rig in your editor, with `riffer acp`
 - [Extensions](docs/EXTENSIONS.md) — your own tools, commands and hooks
 
-## Development
-
-```bash
-bin/setup   # install gems and RBS signatures
-bin/ci      # lint, test, type-check and build the docs, as CI does
-```
-
-`AGENTS.md` lists every script and the project's conventions. PR titles follow [Conventional Commits](https://www.conventionalcommits.org/); [release-please](https://github.com/googleapis/release-please) turns them into releases.
-
 ## Contributing
 
-Fork the repository, make your change on a branch, run `bin/ci`, and open a pull request with a clear description. Please follow the [Code of Conduct](CODE_OF_CONDUCT.md).
+[`AGENTS.md`](AGENTS.md) has the scripts and the project's conventions. Please follow the [Code of Conduct](CODE_OF_CONDUCT.md).
 
 ## License
 

data/lib/riffer/rig/acp/mapper.rb

@@ -27,6 +27,18 @@ module Riffer::Rig::ACP::Mapper
     blocks.filter_map { |block| prompt_text_of(block) }.join("\n\n")
   end
 
+  # @rbs event: ::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event
+  # @rbs return: ::ACP::Types::SessionUpdate::t?
+  def update_for(event)
+    case event
+    when Riffer::StreamEvents::TextDelta then message_chunk(event.content)
+    when Riffer::Rig::Events::CommandOutput then message_chunk(event.text)
+    when Riffer::StreamEvents::ToolCallDone then tool_call(event)
+    when Riffer::Rig::Events::AfterToolCall then tool_call_done(event)
+    when Riffer::Rig::Events::JobExit then job_exit
+    end
+  end
+
   # @rbs content: String
   # @rbs return: ::ACP::Types::SessionUpdate::AgentMessageChunk
   def message_chunk(content)
@@ -96,10 +108,10 @@ module Riffer::Rig::ACP::Mapper
   def stop_reason_of(stop_reason)
     case stop_reason
     when :completed then ::ACP::Types::StopReason::END_TURN
-    when Riffer::Rig::Runtime::INTERRUPT_CANCELLED then ::ACP::Types::StopReason::CANCELLED
+    when Riffer::Rig::Runtime::StopReason::INTERRUPT_CANCELLED then ::ACP::Types::StopReason::CANCELLED
     when :max_steps then ::ACP::Types::StopReason::MAX_TURN_REQUESTS
     else
-      stopped = Riffer::Rig::Runtime::STOPPED_WITHOUT_COMPLETING.include?(stop_reason)
+      stopped = Riffer::Rig::Runtime::StopReason::STOPPED_WITHOUT_COMPLETING.include?(stop_reason)
       stopped ? ::ACP::Types::StopReason::MAX_TOKENS : ::ACP::Types::StopReason::REFUSAL
     end
   end

data/lib/riffer/rig/acp/servers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::ACP::Servers
+  extend self
+
+  # @rbs servers: Array[::ACP::Types::McpServer::t]
+  # @rbs return: Hash[String, Riffer::Rig::Mcp::Declaration]
+  def declarations(servers)
+    servers.filter_map { |server| declaration_of(server) }.to_h
+  end
+
+  # @rbs servers: Array[::ACP::Types::McpServer::t]
+  # @rbs return: Array[String]
+  def warnings(servers)
+    servers.filter_map do |server|
+      next if server.is_a?(::ACP::Types::McpServerStdio)
+
+      "Skipped MCP server #{name_of(server)}: only stdio servers are supported"
+    end
+  end
+
+  private
+
+  # @rbs server: ::ACP::Types::McpServer::t
+  # @rbs return: [String, Riffer::Rig::Mcp::Declaration]?
+  def declaration_of(server)
+    return unless server.is_a?(::ACP::Types::McpServerStdio)
+
+    [
+      server.name,
+      Riffer::Rig::Mcp::Declaration.new(
+        command: server.command, args: server.args, env: server.env.to_h { |variable| [variable.name, variable.value] }
+      )
+    ]
+  end
+
+  # @rbs server: ::ACP::Types::McpServer::t
+  # @rbs return: String
+  def name_of(server)
+    server.is_a?(Hash) ? server['name'].to_s : server.name
+  end
+end

data/lib/riffer/rig/acp.rb

@@ -36,10 +36,6 @@ class Riffer::Rig::ACP
     new(input: input, output: output, env: env, home: home, cwd: cwd, build: build, adopt: adopt)
   end
 
-  # Builds the Runtime a session runs on: the client's MCP servers flow
-  # through the rig.mcp seam as a synthetic extension, so a reload rebuild
-  # re-declares them and a same-name declaration from an extension replaces
-  # them with the usual notify.
   # @rbs cwd: String
   # @rbs host: Riffer::Rig::Hosts::_Host
   # @rbs servers: Hash[String, Riffer::Rig::Mcp::Declaration]
@@ -57,6 +53,8 @@ class Riffer::Rig::ACP
   def self.session_extensions(servers)
     return [] if servers.empty?
 
+    # A synthetic extension, so a reload rebuild re-declares the servers and an
+    # extension's same-name declaration replaces them with the usual notify.
     extension = Riffer::Rig::Extension.new(SESSION_EXTENSION) do |rig|
       servers.each { |name, server| rig.mcp(name, command: server.command, args: server.args, env: server.env) }
     end
@@ -88,8 +86,6 @@ class Riffer::Rig::ACP
     @lock = Mutex.new
   end
 
-  # Serves the connection until the client closes stdin; then the reader
-  # thread ends and run returns.
   # @rbs &block: ? (::ACP::AgentConnection) -> void
   # @rbs return: Integer
   def run
@@ -129,7 +125,7 @@ class Riffer::Rig::ACP
     end
     ::ACP::Types::NewSessionResponse.new(session_id: runtime.id)
   rescue StandardError => e
-    ::ACP::RequestError.new(code: ::ACP::RequestError::INTERNAL_ERROR, message: e.message)
+    internal_error(e)
   end
 
   # @rbs request: ::ACP::Types::PromptRequest
@@ -143,19 +139,10 @@ class Riffer::Rig::ACP
     stop_reason = :completed
     dispatch(runtime, Riffer::Rig::ACP::Mapper.prompt_text(request.prompt)) do |event|
       case event
-      when Riffer::StreamEvents::TextDelta
-        client.update(request.session_id, Riffer::Rig::ACP::Mapper.message_chunk(event.content))
-      when Riffer::Rig::Events::CommandOutput
-        client.update(request.session_id, Riffer::Rig::ACP::Mapper.message_chunk(event.text))
-      when Riffer::StreamEvents::ToolCallDone
-        client.update(request.session_id, Riffer::Rig::ACP::Mapper.tool_call(event))
-      when Riffer::Rig::Events::AfterToolCall
-        client.update(request.session_id, Riffer::Rig::ACP::Mapper.tool_call_done(event))
-      when Riffer::Rig::Events::JobExit
-        client.update(request.session_id, Riffer::Rig::ACP::Mapper.job_exit)
-      when Riffer::Rig::Events::TurnEnd
-        stop_reason = event.stop_reason
+      when Riffer::Rig::Events::TurnEnd then stop_reason = event.stop_reason
       end
+      update = Riffer::Rig::ACP::Mapper.update_for(event)
+      client.update(request.session_id, update) if update
     end
     # A reload in the dispatch, by /reload or the automatic check, can change
     # the commands; its rebuild also reorders them, which is no change.
@@ -168,9 +155,7 @@ class Riffer::Rig::ACP
       message: 'a prompt is already running on this session; wait for it to finish or cancel it'
     )
   rescue StandardError => e
-    ::ACP::RequestError.new(
-      code: ::ACP::RequestError::INTERNAL_ERROR, message: Riffer::Rig::Runtime::ErrorMessage.of(e)
-    )
+    internal_error(e)
   end
 
   # @rbs request: ::ACP::Types::LoadSessionRequest
@@ -192,7 +177,7 @@ class Riffer::Rig::ACP
     client.available_commands(request.session_id, available_commands(runtime))
     ::ACP::Types::LoadSessionResponse.new
   rescue StandardError => e
-    ::ACP::RequestError.new(code: ::ACP::RequestError::INTERNAL_ERROR, message: e.message)
+    internal_error(e)
   end
 
   # @rbs request: ::ACP::Types::ListSessionsRequest
@@ -215,7 +200,7 @@ class Riffer::Rig::ACP
     end
     ::ACP::Types::ListSessionsResponse.new(sessions: sessions)
   rescue StandardError => e
-    ::ACP::RequestError.new(code: ::ACP::RequestError::INTERNAL_ERROR, message: e.message)
+    internal_error(e)
   end
 
   # Runs on the transport's reader thread, so it asks the turn to stop and
@@ -255,6 +240,12 @@ class Riffer::Rig::ACP
     @lock.synchronize { @sessions[id] }
   end
 
+  # @rbs error: StandardError
+  # @rbs return: ::ACP::RequestError
+  def internal_error(error)
+    ::ACP::RequestError.new(code: ::ACP::RequestError::INTERNAL_ERROR, message: Riffer::Rig::Runtime::ErrorMessage.of(error))
+  end
+
   # @rbs runtime: Riffer::Rig::Runtime
   # @rbs text: String
   # @rbs &: (::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event) -> void
@@ -312,38 +303,8 @@ class Riffer::Rig::ACP
   # @rbs host: Riffer::Rig::ACP::Host
   # @rbs return: Hash[String, Riffer::Rig::Mcp::Declaration]
   def declarations(servers, host)
-    servers.filter_map { |server| declaration_of(server, host) }.to_h
-  end
-
-  # @rbs server: ::ACP::Types::McpServer::t
-  # @rbs host: Riffer::Rig::ACP::Host
-  # @rbs return: [String, Riffer::Rig::Mcp::Declaration]?
-  def declaration_of(server, host)
-    unless server.is_a?(::ACP::Types::McpServerStdio)
-      host.notify("Skipped MCP server #{server_name(server)}: only stdio servers are supported", level: :warning)
-      return nil
-    end
-
-    [
-      server.name,
-      Riffer::Rig::Mcp::Declaration.new(command: server.command, args: server.args, env: stdio_env(server))
-    ]
-  end
-
-  # @rbs server: ::ACP::Types::McpServer::t
-  # @rbs return: String
-  def server_name(server)
-    case server
-    when ::ACP::Types::McpServer::Http, ::ACP::Types::McpServer::Sse then server.name
-    when Hash then server['name'].to_s
-    else 'unnamed'
-    end
-  end
-
-  # @rbs server: ::ACP::Types::McpServerStdio
-  # @rbs return: Hash[String, String]
-  def stdio_env(server)
-    server.env.to_h { |variable| [variable.name, variable.value] }
+    Riffer::Rig::ACP::Servers.warnings(servers).each { |warning| host.notify(warning, level: :warning) }
+    Riffer::Rig::ACP::Servers.declarations(servers)
   end
 
   # @rbs runtime: Riffer::Rig::Runtime

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

@@ -9,6 +9,8 @@ class Riffer::Rig::CLI::Flags
            riffer acp           serve Runtimes as an ACP agent over stdio
   TEXT
 
+  HEADLESS_ONLY = %i[verbose json job-idle-timeout].freeze #: Array[Symbol]
+
   # @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?
@@ -34,6 +36,9 @@ class Riffer::Rig::CLI::Flags
     return "invalid argument: --max-steps #{flags.max_steps}" if flags.max_steps&.<(1)
     return "invalid argument: --job-idle-timeout #{flags.job_idle_timeout}" if flags.job_idle_timeout&.negative?
 
+    stray = HEADLESS_ONLY.find { |key| values.key?(key) } unless flags.headless || flags.help || flags.version
+    return "--#{stray} is only available with -p" if stray
+
     flags
   rescue OptionParser::ParseError => e
     e.message

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

@@ -3,9 +3,6 @@
 class Riffer::Rig::CLI::Sessions
   OFF = 'Sessions are off for this run (--no-save).' #: String
 
-  # The terminal's sessions collaborator: translates the parsed flags into
-  # Loader builds and store lookups, so the host never sees the flags.
-  #
   # @rbs @flags: Riffer::Rig::CLI::Flags
   # @rbs @env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
   # @rbs @cwd: String

data/lib/riffer/rig/cli.rb

@@ -31,9 +31,6 @@ module Riffer::Rig::CLI
     return refuse(flags, error) if flags.is_a?(String)
     return help(output) if flags.help
     return version(output) if flags.version
-    return refuse('--verbose is only available with -p', error) if flags.verbose && !flags.headless
-    return refuse('--json is only available with -p', error) if flags.json && !flags.headless
-    return refuse('--job-idle-timeout is only available with -p', error) if flags.job_idle_timeout && !flags.headless
 
     return headless(flags, input:, output:, error:, env:, cwd:, home:) if flags.headless
 

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

@@ -5,22 +5,28 @@ module Riffer::Rig::Commands::Auth
 
   USAGE = 'Use /auth, /auth <provider> or /auth remove <provider>' #: String
 
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
   # @rbs return: Riffer::Rig::Command
-  def command
+  def command(env:, auth_path:, settings_path:)
     Riffer::Rig::Command.new(
       'auth',
       description: 'Show, re-run or remove provider credentials',
       extension: :core
-    ) { |ctx| run(ctx) }
+    ) { |ctx| run(ctx, env:, auth_path:, settings_path:) }
   end
 
   # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
   # @rbs return: void
-  def run(ctx)
+  def run(ctx, env:, auth_path:, settings_path:)
     words = ctx.args.split
-    return list(ctx) if words.empty?
-    return remove(ctx, words[1]) if words[0] == 'remove' && words.length == 2
-    return rerun(ctx, words[0]) if words.length == 1
+    return list(ctx, env:, auth_path:) if words.empty?
+    return remove(ctx, words[1], auth_path:, settings_path:) if words[0] == 'remove' && words.length == 2
+    return rerun(ctx, words[0], env:, auth_path:, settings_path:) if words.length == 1
 
     ctx.say(USAGE)
   end
@@ -34,10 +40,12 @@ module Riffer::Rig::Commands::Auth
   end
 
   # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
   # @rbs return: void
-  def list(ctx)
+  def list(ctx, env:, auth_path:)
     statuses = Riffer::Rig::Providers.identifiers.to_h do |identifier|
-      [identifier, Riffer::Rig::Credentials.status(identifier)]
+      [identifier, Riffer::Rig::Credentials.status(identifier, env:, auth_path:)]
     end
     unreadable = statuses.values.grep(String) #: Array[String]
     return ctx.host.notify(unreadable.first, level: :error) if unreadable.any?
@@ -48,30 +56,30 @@ module Riffer::Rig::Commands::Auth
 
   # @rbs ctx: Riffer::Rig::Command::Context
   # @rbs identifier: String
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
   # @rbs return: void
-  def rerun(ctx, identifier)
+  def rerun(ctx, identifier, env:, auth_path:, settings_path:)
     return ctx.say(hint) unless Riffer::Providers::Repository.find(identifier)
 
     provider = identifier.to_sym
-    resolution = Riffer::Rig::Credentials.install(provider, host: ctx.host)
-    return ctx.host.notify(resolution, level: :error) if resolution.is_a?(String)
+    values = Riffer::Rig::Credentials.install_values(provider, host: ctx.host, env:, auth_path:, settings_path:)
+    return ctx.host.notify(values, level: :error) if values.is_a?(String)
 
-    if resolution.missing.any?
-      missing_fields = Riffer::Rig::ProviderSetup.for(provider).missing_fields(resolution.missing)
-      ctx.host.notify("#{provider} still has no #{missing_fields}", level: :error)
-    else
-      ctx.runtime.merge_credentials(provider, resolution.values)
-      ctx.say("Updated #{provider} credentials")
-    end
+    ctx.runtime.merge_credentials(provider, values)
+    ctx.say("Updated #{provider} credentials")
   end
 
   # @rbs ctx: Riffer::Rig::Command::Context
   # @rbs identifier: String
+  # @rbs auth_path: String
+  # @rbs settings_path: String
   # @rbs return: void
-  def remove(ctx, identifier)
+  def remove(ctx, identifier, auth_path:, settings_path:)
     return ctx.say(hint) unless Riffer::Providers::Repository.find(identifier)
 
-    refusal = Riffer::Rig::Credentials.remove(identifier)
+    refusal = Riffer::Rig::Credentials.remove(identifier, auth_path:, settings_path:)
     return ctx.host.notify(refusal, level: :error) if refusal
 
     ctx.say("Removed stored #{identifier} credentials")

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

@@ -4,20 +4,27 @@ module Riffer::Rig::Commands::Model
   extend self
 
   SAVE = '--save' #: String
-  SAVED_TO = '~/.riffer/settings.json' #: String
 
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
+  # @rbs sdk: singleton(Riffer::Rig::SDK)
   # @rbs return: Riffer::Rig::Command
-  def command
+  def command(env:, auth_path:, settings_path:, sdk: Riffer::Rig::SDK)
     Riffer::Rig::Command.new(
       'model',
       description: 'Switch the model for this session: /model provider/name, /model --save',
       extension: :core
-    ) { |ctx| run(ctx) }
+    ) { |ctx| run(ctx, env:, auth_path:, settings_path:, sdk:) }
   end
 
   # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
+  # @rbs sdk: singleton(Riffer::Rig::SDK)
   # @rbs return: void
-  def run(ctx)
+  def run(ctx, env:, auth_path:, settings_path:, sdk:)
     words = ctx.args.split
     save = words.delete(SAVE)
     model = words.join(' ')
@@ -25,21 +32,21 @@ module Riffer::Rig::Commands::Model
     if model.empty?
       return ctx.say("Model: #{ctx.runtime.model}") unless save
 
-      refusal = Riffer::Rig::Settings::File.store_model(ctx.runtime.model)
+      refusal = Riffer::Rig::Settings::File.store_model(ctx.runtime.model, path: settings_path)
       return ctx.host.notify(refusal, level: :error) if refusal
 
-      return ctx.say("Saved #{ctx.runtime.model} to #{SAVED_TO}")
+      return ctx.say("Saved #{ctx.runtime.model} to #{settings_path}")
     end
 
     provider = Riffer::Rig::Settings::ModelOptions.provider_for(model)
     return ctx.say(hint) unless provider && Riffer::Providers::Repository.find(provider)
-    return unless ready?(ctx, model, provider)
+    return unless ready?(ctx, model, provider, env:, auth_path:, settings_path:, sdk:)
 
     ctx.runtime.model = model
-    refusal = Riffer::Rig::Settings::File.store_model(model) if save
+    refusal = Riffer::Rig::Settings::File.store_model(model, path: settings_path) if save
     ctx.host.notify(refusal, level: :error) if refusal
     saved = save && !refusal
-    ctx.say(saved ? "Model switched to #{model} and saved to #{SAVED_TO}" : "Model switched to #{model}")
+    ctx.say(saved ? "Model switched to #{model} and saved to #{settings_path}" : "Model switched to #{model}")
   end
 
   private
@@ -54,29 +61,36 @@ module Riffer::Rig::Commands::Model
   # @rbs ctx: Riffer::Rig::Command::Context
   # @rbs model: String
   # @rbs provider: String
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
+  # @rbs sdk: singleton(Riffer::Rig::SDK)
   # @rbs return: bool
-  def ready?(ctx, model, provider)
+  def ready?(ctx, model, provider, env:, auth_path:, settings_path:, sdk:)
     setup = Riffer::Rig::ProviderSetup.registered_setup(provider)
     return true unless setup
 
-    sdk = setup.sdk
-    if sdk
-      message = Riffer::Rig::SDK.ensure(sdk[0], sdk[1], host: ctx.host)
+    gem = setup.sdk
+    if gem
+      message = sdk.ensure(gem[0], gem[1], host: ctx.host)
       if message
         ctx.host.notify(message, level: :error)
         return false
       end
     end
 
-    credentials_ready?(ctx, model, provider, setup)
+    credentials_ready?(ctx, model, provider, setup, env:, auth_path:, settings_path:)
   end
 
   # @rbs ctx: Riffer::Rig::Command::Context
   # @rbs model: String
   # @rbs provider: String
   # @rbs setup: Riffer::Rig::ProviderSetup
+  # @rbs env: Riffer::Rig::Env
+  # @rbs auth_path: String
+  # @rbs settings_path: String
   # @rbs return: bool
-  def credentials_ready?(ctx, model, provider, setup)
+  def credentials_ready?(ctx, model, provider, setup, env:, auth_path:, settings_path:)
     missing = setup.fields.select(&:required)
                    .map(&:name)
                    .reject { |name| ctx.runtime.credentials.dig(provider.to_sym, name) }
@@ -84,26 +98,15 @@ module Riffer::Rig::Commands::Model
 
     empty = {} #: Hash[Symbol, String]
     stored = ctx.runtime.credentials.fetch(provider.to_sym, empty)
-    resolution = Riffer::Rig::Credentials.install(provider, host: ctx.host, known: stored)
-    if resolution.is_a?(String)
-      ctx.host.notify(resolution, level: :error)
-      false
-    elsif resolution.missing.any?
-      refuse(ctx, model, provider, missing & resolution.missing)
-      false
-    else
-      ctx.runtime.merge_credentials(provider.to_sym, stored.merge(resolution.values))
-      true
+    values = Riffer::Rig::Credentials.install_values(
+      provider, host: ctx.host, env:, auth_path:, settings_path:, setup:, known: stored
+    )
+    if values.is_a?(String)
+      ctx.host.notify("Not switching to #{model}: #{values}", level: :error)
+      return false
     end
-  end
 
-  # @rbs ctx: Riffer::Rig::Command::Context
-  # @rbs model: String
-  # @rbs provider: String
-  # @rbs missing: Array[Symbol]
-  # @rbs return: void
-  def refuse(ctx, model, provider, missing)
-    wanted = Riffer::Rig::ProviderSetup.for(provider).missing_fields(missing)
-    ctx.host.notify("Not switching to #{model}: #{provider} has no #{wanted}", level: :error)
+    ctx.runtime.merge_credentials(provider.to_sym, stored.merge(values))
+    true
   end
 end

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

@@ -4,43 +4,43 @@ module Riffer::Rig::Commands::Reasoning
   extend self
 
   SAVE = '--save' #: String
-  SAVED_TO = '~/.riffer/settings.json' #: String
-  DEFAULT = 'default' #: String
 
+  # @rbs settings_path: String
   # @rbs return: Riffer::Rig::Command
-  def command
+  def command(settings_path:)
     Riffer::Rig::Command.new(
       'reasoning',
       description: 'Switch the reasoning level for this session: /reasoning high, /reasoning --save',
       extension: :core
-    ) { |ctx| run(ctx) }
+    ) { |ctx| run(ctx, settings_path:) }
   end
 
   # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs settings_path: String
   # @rbs return: void
-  def run(ctx)
+  def run(ctx, settings_path:)
     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("Reasoning: #{current || Riffer::Rig::Runtime::DEFAULT_REASONING_LABEL}") unless save
       return ctx.say('No reasoning level is in effect to save') unless current
 
-      refusal = Riffer::Rig::Settings::File.store_reasoning(current)
+      refusal = Riffer::Rig::Settings::File.store_reasoning(current, path: settings_path)
       return ctx.host.notify(refusal, level: :error) if refusal
 
-      return ctx.say("Saved #{current} to #{SAVED_TO}")
+      return ctx.say("Saved #{current} to #{settings_path}")
     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
+    refusal = Riffer::Rig::Settings::File.store_reasoning(level, path: settings_path) 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}")
+    ctx.say(saved ? "Reasoning switched to #{level} and saved to #{settings_path}" : "Reasoning switched to #{level}")
   end
 end

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

@@ -3,21 +3,21 @@
 module Riffer::Rig::Commands::Reload
   extend self
 
-  # @rbs loader: Riffer::Rig::Loader
+  # @rbs reloader: Riffer::Rig::Loader::Reloader
   # @rbs return: Riffer::Rig::Command
-  def command(loader)
+  def command(reloader)
     Riffer::Rig::Command.new(
       'reload',
       description: 'Reload the rig.rb files, settings, credentials and trust',
       extension: :core
-    ) { |ctx| run(loader, ctx) }
+    ) { |ctx| run(reloader, ctx) }
   end
 
-  # @rbs loader: Riffer::Rig::Loader
+  # @rbs reloader: Riffer::Rig::Loader::Reloader
   # @rbs ctx: Riffer::Rig::Command::Context
   # @rbs return: void
-  def run(loader, ctx)
-    reloaded = loader.reload(ctx.runtime, force: true)
+  def run(reloader, ctx)
+    reloaded = reloader.reload(ctx.runtime, force: true)
     ctx.say('Reloaded') if reloaded.is_a?(Riffer::Rig::Runtime)
   end
 end