samagotchi 0.155.0 → 0.156.0

data/lib/samagotchi/engine/models.rb

@@ -228,13 +228,16 @@ module Samagotchi
       private
 
       # Pick the loop for +model+ (EffectiveModel); the chat loop is pointed
-      # at its host's adapter (one per host, kept for its cached model list).
+      # at its host's adapter (one per host, kept for its cached model list)
+      # and client (the window probe, the re-prefill's host).
       def backend_for(model)
         return @native_backend unless model.chat?
 
         @chat_backend_mutex.synchronize do
-          @chat_backend ||= LLM::ChatLoop.new(kernel: @kernel, stable_length: ->(text) { @prompt_builder.stable_length(text) })
+          @chat_backend ||= LLM::ChatLoop.new(kernel: @kernel, reprefill: @reprefill,
+                                              stable_length: ->(text) { @prompt_builder.stable_length(text) })
           @chat_backend.adapter = @host_registry.adapter_for(model.entry)
+          @chat_backend.client = model.client
           @chat_backend.session_id = session&.id
           @chat_backend
         end

data/lib/samagotchi/engine/objectives.rb

@@ -9,8 +9,22 @@ module Samagotchi
     # @host_registry, @session.
     module ObjectivesPart
       # The session's objectives as the page draws them, when that differs
-      # from the last announced (TurnStages::Objectives#announce).
-      def announce_objectives(session = @session) = @objectives_stage.announce(session)
+      # from the last announced (TurnStages::Objectives#announce), from any
+      # thread: end_turn's step, a command, Check this's thread, a note,
+      # a rollback. Under the event lock, which guards the last view: the
+      # sessions dir and the running turn's conversation read there, the
+      # event announced in the same step. It only informs: a failure is
+      # logged, never raised.
+      def announce_objectives(session = @session)
+        return unless session
+
+        synchronize_events do
+          event = @objectives_stage.announce(session, state_dir: session_state_dir, running: live_conversation)
+          announce(event) if event
+        end
+      rescue StandardError => e
+        Log.warn(:turn, "objectives_announce_failed", error: e.class.name, msg: e.message)
+      end
 
       # Check this (ObjectivesCheck)'s one side request. Its usage is in the
       # session's side line. Raises as ctx.ask_model's request does.
@@ -32,16 +46,20 @@ module Samagotchi
       # The objectives' stage (TurnStages::Objectives).
       attr_reader :objectives_stage
 
-      # The stage over this Engine's side asks and its event lock (built in
-      # #initialize, once the host registry is).
+      # However +turn+ ended (run_turn's ensure, after the turn flag is
+      # released): a completed turn's proposal cards shown
+      # (TurnStages::Objectives#finally). A card that fails is logged.
+      def show_objective_proposals(turn)
+        @objectives_stage.finally(turn).each { |card| show_card(**card) }
+      rescue StandardError => e
+        Log.warn(:turn, "objectives_proposal_failed", error: e.class.name, msg: e.message)
+      end
+
+      # The stage over this Engine's side asks (built in #initialize, once
+      # the host registry is). Each call takes its values: the recorder,
+      # the sessions dir, the running conversation.
       def build_objectives_stage
-        TurnStages::Objectives.new(
-          side_judgments: @side_judgments, host_registry: @host_registry, state_dir: -> { session_state_dir },
-          recording: ->(client, judgment, session, mode:) { system_one_recording(client, judgment, session, mode: mode) },
-          runs: -> { system_one_runs }, synchronize: ->(&block) { synchronize_events(&block) },
-          announce: ->(event) { announce(event) }, running: -> { live_conversation },
-          show_card: ->(**card) { show_card(**card) }
-        )
+        TurnStages::Objectives.new(side_judgments: @side_judgments, host_registry: @host_registry)
       end
     end
   end

data/lib/samagotchi/engine/side_requests.rb

@@ -6,6 +6,7 @@ module Samagotchi
     # IdleClient, their usage in the session's side line, and System 1's
     # recording of judged asks. Writes @side_client/@side_client_key (under
     # @side_client_mutex); reads @metrics, @session, @host_registry.
+    # The recorder (SystemOne::Recorder) is the turn stages' recording seam.
     module SideRequestsPart
       # Count one side request (a recap, a plugin's ctx.ask_model: IdleClient's
       # on_usage) in the session's side line, apart from its turns' totals.
@@ -52,24 +53,33 @@ module Samagotchi
 
       private
 
-      # +client+ (nil for none) saving its asks as +judgment+'s runs. Anything
-      # going wrong here leaves the client as it was: a run is never worth a
-      # judgment.
-      #
-      # A scratch session's asks aren't saved; a participant's turn is never
-      # judged, so it never comes here.
+      # +client+ (nil for none) saving its asks as +judgment+'s runs
+      # (SystemOne::Recorder#wrap, over a recorder built now): the
+      # guardrails' System 1 client. No client or a scratch session: the
+      # client as it is, with nothing read (no recorder built).
       # @param mode [String, nil] the use's mode, for its runs (Recording.wrap)
       def system_one_recording(client, judgment, session, mode: nil)
         return client if client.nil? || session&.scratch
 
-        context = SystemOne::Recording::Context.of(session, session_model: session && effective_model_name)
-        SystemOne::Recording.wrap(client, judgment: judgment, runs: system_one_runs, context: context, recorded_mode: mode)
-      rescue StandardError => e
-        Log.warn(:system_one, "system_one_recording_failed", error: e.class.name, msg: e.message.to_s[0, 200])
-        client
+        system_one_recorder.wrap(client, judgment, session, mode: mode)
       end
       private :system_one_recording
 
+      # What a turn stage saves its System 1 asks with (SystemOne::Recorder):
+      # this Engine's runs and the model it names now, read at this call and
+      # never kept, so each stage call sees the model as it is then (an
+      # outgoing ask after a before_turn hook's switch, the new one). Never
+      # raises: on a failure, SystemOne::Recorder::NONE (no runs, the plain
+      # client), said once per failure as before.
+      # @return [SystemOne::Recorder]
+      def system_one_recorder
+        SystemOne::Recorder.new(runs: system_one_runs, session_model: effective_model_name)
+      rescue StandardError => e
+        SystemOne::Recorder.failed(e)
+        SystemOne::Recorder::NONE
+      end
+      private :system_one_recorder
+
       # Where this Engine's runs are saved; read each time, as the settings are.
       def system_one_runs = SystemOne::Runs.for_sessions_dir(session_state_dir)
       private :system_one_runs

data/lib/samagotchi/engine/toolkit.rb

@@ -22,10 +22,14 @@ module Samagotchi
       # turn's staged tool sets and its toolkit apply.
       def publish_tools! = @toolkit_binding.publish!
 
+      # That published Registry (ToolkitBinding#published): what a reader
+      # off the turn thread (/toolkit) reads of the tools.
+      def published_tools = @toolkit_binding.published
+
       # The tools this session registered (Tools::Registry), declared or not.
       attr_reader :tools
 
-      public :tools, :toolkit_kits, :resolved_toolkit, :toolkit_explained, :toolkit_summary
+      public :tools, :published_tools, :toolkit_kits, :resolved_toolkit, :toolkit_explained, :toolkit_summary
 
       # A plugin's ctx.load_tools: stage the reachable tools +names+ names
       # (Tools::ToolIndex#deferred_name, on the published Registry) that the
@@ -35,7 +39,7 @@ module Samagotchi
       # @return [Array<String>] the wire names staged
       def load_tools(names, bundle)
         added = ToolLoads.added(@session&.messages)
-        published = @toolkit_binding.published
+        published = published_tools
         surface = Tools::ToolSurface.for(published)
         wanted = names.filter_map do |name|
           wire = @tool_index.deferred_name(name, surface)
@@ -97,14 +101,11 @@ module Samagotchi
       public :warm_toolkit_suggestion!
 
       # The stage over this Engine's side asks, binding and tools (built in
-      # #build_tools_and_plugins, before the plugins load).
+      # #build_tools_and_plugins, before the plugins load). Its turn's start
+      # takes the recorder (#system_one_recorder) per call.
       def build_toolkit_suggestion
-        TurnStages::ToolkitSuggestion.new(
-          side_judgments: @side_judgments, host_registry: @host_registry, toolkit_binding: @toolkit_binding,
-          tools: @tools, state_dir: -> { session_state_dir },
-          recording: ->(client, judgment, session, mode:) { system_one_recording(client, judgment, session, mode: mode) },
-          runs: -> { system_one_runs }
-        )
+        TurnStages::ToolkitSuggestion.new(side_judgments: @side_judgments, host_registry: @host_registry,
+                                          toolkit_binding: @toolkit_binding, tools: @tools)
       end
       private :build_toolkit_suggestion
     end

data/lib/samagotchi/engine/turn_end.rb

@@ -117,7 +117,7 @@ module Samagotchi
         # a display version of the answer (AnswerDisplay) and event[:refs]
         # for refs on it (AnswerRefs).
         session = turn.session
-        @objectives_stage.outgoing(turn, result) unless canceled || result.exhausted?
+        @objectives_stage.outgoing(turn, result, recorder: system_one_recorder) unless canceled || result.exhausted?
         display = AnswerDisplay.new(session.messages)
         refs = AnswerRefs.new(session.messages, cwd: session.working_directory)
         after_turn = { type: :after_turn, status: canceled ? "canceled" : "completed",

data/lib/samagotchi/engine/turn_helpers.rb

@@ -7,7 +7,7 @@ module Samagotchi
     # with, the used memories it publishes, and the turn-end warm-up of the
     # next one (TurnStages::Warmup, built here). Writes @next_turn_waiting;
     # reads @model_settings, @kernel, @prompt_warmup, @thinking_notices,
-    # @turn_state, @turn_warmup.
+    # @turn_state, @reminder_queue, @turn_warmup.
     module TurnHelpersPart
       # The turn's settings for the kernel (LLM::TurnSettings): vision,
       # sampling and thinking, the thinking resolved before the hooks run.
@@ -40,13 +40,13 @@ module Samagotchi
       private :turn_warmup
 
       # The stage over the kernel and the Engine's PromptWarmup (built in
-      # #initialize, once the kernel is).
+      # #initialize, once the kernel and the reminder queue are). Its one
+      # callable is the system prompt, built late (side effects); the
+      # host's probe goes with each call (#next_turn_waiting, set after).
       def build_turn_warmup
-        TurnStages::Warmup.new(
-          prompt_warmup: @prompt_warmup, kernel: @kernel, turn_state: @turn_state, model_settings: @model_settings,
-          model: -> { effective_model }, system_prompt: ->(model) { system_prompt(model) },
-          reminders_due: -> { reminders_due? }, next_turn_waiting: -> { next_turn_waiting&.call }
-        )
+        TurnStages::Warmup.new(prompt_warmup: @prompt_warmup, kernel: @kernel, turn_state: @turn_state,
+                               model_settings: @model_settings, reminder_queue: @reminder_queue,
+                               system_prompt: ->(model) { system_prompt(model) })
       end
       private :build_turn_warmup
 

data/lib/samagotchi/engine/verify.rb

@@ -11,7 +11,7 @@ module Samagotchi
       # The anchors' stage (TurnStages::VerifyAnchors).
       attr_reader :verify_anchors
 
-      def build_verify_anchors = TurnStages::VerifyAnchors.new(state_dir: -> { session_state_dir })
+      def build_verify_anchors = TurnStages::VerifyAnchors.new
     end
   end
 end

data/lib/samagotchi/engine.rb

@@ -27,6 +27,7 @@ require_relative "thinking_notices"
 require_relative "cancellation_controller"
 require_relative "context_window"
 require_relative "kernel_loop"
+require_relative "reprefill_meter"
 require_relative "tools/builtins"
 require_relative "tools/task_runtime"
 require_relative "tools/tool_index"
@@ -55,6 +56,7 @@ require_relative "context_judge"
 require_relative "objectives_audit"
 require_relative "owner_prompt"
 require_relative "side_judgments"
+require_relative "system_one/recorder"
 require_relative "toolkit_suggest"
 require_relative "turn_stages/context_judge"
 require_relative "turn_stages/objectives"
@@ -451,6 +453,9 @@ module Samagotchi
       self.guardrail_state_dir = Session.default_state_dir
       # The turn-end warm-up; the kernel asks it for a slot pin per request.
       @prompt_warmup = PromptWarmup.new
+      # One re-prefill baseline for both loops (the native kernel's and the
+      # chat loop's requests), reset by the warm-up (KernelLoop#warmed_up!).
+      @reprefill = ReprefillMeter.new
       services = KernelLoop::Services.new(
         hooks: @hooks, tools: @tools, reminder_store: @reminder_store, muted_memory_names: @muted_memory_names,
         # ask_user_question blocks on the Engine's question flow (TUI/Web answer it).
@@ -466,8 +471,8 @@ module Samagotchi
       )
       # A given kernel (specs) gets the same services as the one built here.
       @kernel = kernel || KernelLoop.new(client: @client, profile: @model_binding.given_profile,
-                                         model_name: effective_model_name, services: services)
-      @kernel.attach(services) if kernel
+                                         model_name: effective_model_name, services: services, reprefill: @reprefill)
+      @kernel.attach(services, reprefill: @reprefill) if kernel
       sync_kernel_client!
       sync_model_key!
       # What a hook can do beyond reading its event (event[:notify],
@@ -727,7 +732,7 @@ module Samagotchi
         event[:verdict] = verdict if verdict
         event[:revises] = revises.to_h if revises
         emit_working_set(turn.on_event, turn.session, turn.session.messages)
-        @objectives_stage.announce(turn.session)
+        announce_objectives(turn.session)
         turn.session.status = Session::STATUS_IDLE
         record_last_turn(turn.session, outcome, seconds, turn.origin, event, limit: exhausted ? turn.limit : nil)
         emit_event(turn.on_event, turn.tag(event))
@@ -911,7 +916,7 @@ module Samagotchi
                                 pending_input: pending_input)
         publish_used_memories(session, on_event)
         complete_turn(turn, result)
-        @turn_warmup.after(turn, result)
+        @turn_warmup.after(turn, result, next_turn_waiting: next_turn_waiting)
         result
       rescue Interrupt => e
         # After the end event (in the after_turn/session_end hooks) the
@@ -941,7 +946,7 @@ module Samagotchi
         @context_judge.show_cards_after_turn
         # Only a completed turn shows its proposal cards; any other's are
         # dropped, so the next turn does not show them either.
-        @objectives_stage.finally(turn)
+        show_objective_proposals(turn)
       end
     end
 
@@ -954,7 +959,7 @@ module Samagotchi
       # A participant's Verify fresh child: every turn is theirs (their
       # author, boundary and cap), whoever started it.
       origin = session.verify_fresh.origin_for(origin) if session.respond_to?(:verify_fresh) && session.verify_fresh
-      verify = @verify_anchors.verified(session, VerifyAnchor.from(verify))
+      verify = @verify_anchors.verified(session, VerifyAnchor.from(verify), state_dir: session_state_dir)
       # Track the active session for recap and status snapshot.
       @session = session
       # status is turn state: running now, idle again before the turn's end
@@ -1044,7 +1049,7 @@ module Samagotchi
       # On mode's ask starts here too; the turn joins it before
       # apply_toolkit! below, so its latency hides behind the probes and
       # the init wait.
-      @toolkit_suggestion.start(turn)
+      @toolkit_suggestion.start(turn, recorder: system_one_recorder)
 
       # The window and the profile probes run after run_turn's probe-cancel
       # swap, so a Stop cuts them; a failure ends the turn as turn_failed.
@@ -1081,8 +1086,8 @@ module Samagotchi
       @toolkit_suggestion.settle(turn)
       # The candidate judge: its asks run beside the turn; on mode's
       # attaches reach the model at the next between-turn delivery.
-      @context_judge.start(turn)
-      @objectives_stage.incoming(turn)
+      @context_judge.start(turn, recorder: system_one_recorder)
+      @objectives_stage.incoming(turn, recorder: system_one_recorder)
       apply_toolkit!(session, turn.on_event)
       refresh_participants!(session)
       # A Stop during the waits above: the turn ends here,

data/lib/samagotchi/guardrails/targets.rb

@@ -113,8 +113,10 @@ module Samagotchi
       # @param model_name [String, nil] the bare model name, for a rule's models:
       # @param registry [Tools::Registry, nil] the session's tools: a plugin
       #   tool's entry says what it acts on (its targets:)
-      # @param surface [Tools::ToolSurface, nil] the turn's: call_tool's
-      #   targets name what the turn reaches (nil: the Registry now)
+      # @param surface [Tools::ToolSurface, nil] the turn's: the entry is
+      #   looked up in it (.entry_of) and call_tool's targets name what it
+      #   reaches (nil: the registry's entry; call_tool's then raises
+      #   Tools::MissingSurface)
       def self.for(call, context, model_key: nil, model_name: nil, registry: nil, surface: nil)
         tool = call[:name].to_s
         base = context.cwd
@@ -143,7 +145,7 @@ module Samagotchi
           given_cwd = given[:cwd].to_s.strip
           cwd = File.expand_path(given_cwd, base) unless given_cwd.empty?
           paths.concat(given[:paths].flat_map { |path| absolutes(path, cwd) })
-          entry = registry && registry[tool]
+          entry = entry_of(tool, registry, surface)
           args = given[:args] || call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
           acts_as = given[:acts_as]
           label = given[:label]
@@ -164,9 +166,12 @@ module Samagotchi
       # logged). args: counts when it is a Hash; acts_as: is dropped (and
       # logged) when it names a core tool or another bundle's tool, so a
       # call can't pass for one and match (or reuse the approvals of) its
-      # rules. label: counts when it is one short line (.label_of).
+      # rules. label: counts when it is one short line (.label_of). A
+      # missing surface (Tools::MissingSurface) is raised, never taken as
+      # nothing: call_tool's acts_as would go missing, and with it the
+      # mcp_* rules on the call (fail-open).
       def self.plugin_targets(call, registry, surface = nil)
-        entry = registry && registry[call[:name].to_s]
+        entry = entry_of(call[:name], registry, surface)
         none = { command: nil, paths: [], cwd: nil, acts_as: nil, args: nil, label: nil }
         return none unless entry && !entry.core? && entry.targets
 
@@ -176,8 +181,10 @@ module Samagotchi
         given = given.transform_keys(&:to_sym)
         command = given[:command].to_s
         { command: command.empty? ? nil : command, paths: Array(given[:paths]).map(&:to_s), cwd: given[:cwd],
-          acts_as: acts_as_of(given[:acts_as], entry, registry), args: given[:args].is_a?(Hash) ? given[:args] : nil,
+          acts_as: acts_as_of(given[:acts_as], entry, registry, surface), args: given[:args].is_a?(Hash) ? given[:args] : nil,
           label: label_of(given[:label], entry) }
+      rescue Tools::MissingSurface
+        raise
       rescue StandardError => e
         Log.warn(:plugins, "plugin_targets_failed", tool: call[:name].to_s, error: e.class.name,
                                                     msg: "#{call[:name]} targets failed: #{e.message}")
@@ -192,24 +199,32 @@ module Samagotchi
       # name, ToolIndex#claimed), so the registry is the wrong owner test,
       # and a bundle tool sharing an MCP tool's name would otherwise take
       # call_tool calls of that tool out of its mcp_* rules.
-      def self.acts_as_of(name, entry, registry)
+      def self.acts_as_of(name, entry, registry, surface = nil)
         name = name.to_s.strip
         return nil if name.empty? || name == entry.name
 
-        other = registry[name]
+        other = entry_of(name, registry, surface)
         whose = if CORE_TOOLS.include?(name) || other&.core? then "a core tool"
                 elsif other && other.source != entry.source && entry.source != Tools::ToolIndex::SOURCE
                   "bundle #{other.source}'s tool"
                 end
         return name unless whose
 
-        if first_drop?(registry, entry.name, name)
+        if first_drop?(registry || surface, entry.name, name)
           Log.warn(:plugins, "plugin_acts_as_dropped", tool: entry.name, acts_as: name,
                                                        msg: "#{entry.name} targets: acts_as #{name} dropped: it is #{whose}")
         end
         nil
       end
 
+      # The tool +name+ names: the turn's entry (+surface+'s registered),
+      # else +registry+'s (a gate without a turn's surface); nil for none.
+      # @return [Tools::Registry::Entry, nil]
+      def self.entry_of(name, registry, surface)
+        name = name.to_s
+        surface ? surface.registered[name] : registry&.[](name)
+      end
+
       # The drops logged, per registry (a session's): each tool's acts_as
       # once, not at every call (targets run several times a call).
       DROPS_LOGGED = ObjectSpace::WeakKeyMap.new

data/lib/samagotchi/host_config.rb

@@ -8,7 +8,7 @@ require_relative "llm/dialect"
 require_relative "reasoning_history"
 
 module Samagotchi
-  # One config.yml hosts: entry, parsed and checked (ConfigFile.hosts_config
+  # One config.yml hosts: entry, parsed and checked (HostConfig.all
   # holds them by lowercased name; HostRegistry builds its HostEntry from
   # one).
   #
@@ -28,6 +28,77 @@ module Samagotchi
       super(**members.to_h { |m| [m, nil] }, models: {}, **fields)
     end
 
+    # config.yml's hosts: by lowercased name; an entry that is disabled or
+    # invalid (warned) is left out. No entry left: "default", from
+    # server.host/port.
+    # @return [Hash{String => HostConfig}]
+    def self.all(env: ENV, path: ConfigFile.global_path(env: env))
+      data = ConfigFile.read_yaml(env: env, path: path)
+      raw_hosts = data[ConfigFile::HOSTS_KEY] if data.is_a?(Hash)
+
+      normalized = {}
+      if raw_hosts.is_a?(Hash)
+        raw_hosts.each do |raw_name, raw_cfg|
+          host = parse(raw_name, raw_cfg)
+          normalized[host.name] = host if host
+        end
+        warn_duplicate_models(normalized)
+      end
+      normalized["default"] = default_host(data, env) if normalized.empty?
+      normalized
+    rescue StandardError => e
+      Log.error(:config, "hosts_config_failed", error: e.class.name, message: e.message)
+      {}
+    end
+
+    # The names (lowercased) of the hosts entries with enabled: false, which
+    # .all leaves out, from config.yml's hosts:.
+    # @return [Array<String>]
+    def self.disabled_names(env: ENV, path: ConfigFile.global_path(env: env))
+      data = ConfigFile.read_yaml(env: env, path: path)
+      raw = data[ConfigFile::HOSTS_KEY] if data.is_a?(Hash)
+      return [] unless raw.is_a?(Hash)
+
+      raw.filter_map { |name, cfg| name.to_s.strip.downcase if cfg.is_a?(Hash) && disabled?(cfg) }
+    rescue StandardError # degrade-ok: Config↔Log: Log resolves its file and level through Config
+      []
+    end
+
+    # +raw+ parsed against config.yml's hosts (or +hosts+) and aliases.
+    # @return [ModelRef]
+    def self.model_ref(raw, env: ENV, path: ConfigFile.global_path(env: env), hosts: nil)
+      ModelRef.parse(raw, hosts: hosts || all(env: env, path: path), aliases: ConfigFile.model_aliases(env: env, path: path))
+    end
+
+    # The host chi uses when hosts: names none: server.host/port.
+    def self.default_host(data, env)
+      opts = { file_data: data, env: env, cli_overrides: Config.cli_overrides }
+      host = Config.resolve("server.host", **opts).to_s.strip
+      host = "localhost" if host.empty?
+      port = Config.resolve("server.port", **opts).to_i
+      port = 8080 if port <= 0 || port > 65_535
+      new(name: "default", host: host, port: port)
+    end
+    private_class_method :default_host
+
+    # Two hosts declaring one id under hosts.<name>.models: a bare id goes
+    # where HostRegistry#host_for_model sends it (the default host when it
+    # declares the id, else the first in hosts: order); say so once.
+    def self.warn_duplicate_models(hosts)
+      declared = Hash.new { |h, k| h[k] = [] }
+      hosts.each { |name, cfg| cfg.models.each { |down, model| declared[down] << [name, model.id] } }
+      declared.each_value do |owners|
+        next if owners.size < 2
+
+        names = owners.map(&:first)
+        id = owners.first.last
+        goes = names.include?("default") ? "default" : "#{names.first} unless the default host lists it"
+        ConfigFile.warn_once "Warning: #{names.map { |n| "hosts.#{n}.models" }.join(" and ")} #{names.size == 2 ? "both" : "all"} " \
+                             "declare #{id}; a bare #{id} goes to #{goes}"
+      end
+    end
+    private_class_method :warn_duplicate_models
+
     # A hosts: entry as written in config.yml,
     # or nil when it is disabled (enabled: false) or invalid. An invalid
     # one warns once, naming the entry, the way each reader of a setting

data/lib/samagotchi/host_model.rb

@@ -67,12 +67,8 @@ module Samagotchi
       served == "any" || served.any? { |id| id.casecmp?(name.to_s.strip) }
     end
 
-    # config.rb requires this file, so config is required here only when a
-    # warning needs it (this file loaded alone).
-    def self.warn_once(message)
-      require_relative "config"
-      ConfigFile.warn_once(message)
-    end
+    # Config comes with model_price.
+    def self.warn_once(message) = ConfigFile.warn_once(message)
     private_class_method :warn_once
 
     # One host's rows as the listings show them, declared ids first, then

data/lib/samagotchi/host_registry.rb

@@ -126,7 +126,7 @@ module Samagotchi
       @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       @adapters = {}
       @host_lists = {}
-      raw = hosts_config || ConfigFile.hosts_config(env: env)
+      raw = hosts_config || HostConfig.all(env: env)
       @entries = {}
       raw.each do |key, cfg|
         cfg = HostConfig.coerce(key, cfg)