samagotchi 0.45.0 → 0.46.1

data/lib/samagotchi/bundles/github-pr/plugin.rb

@@ -616,21 +616,42 @@ class LineLinker
   end
 
   # The PR file +path+ names: the path (or a rename's old one) exactly,
-  # after a leading `./`; else the longest PR path +path+ ends with on a
-  # `/` boundary (an absolute path into a worktree); else the one PR path
-  # that ends with +path+ (a bare `foo.rb`). nil: none, or several.
+  # after a leading `./`; else, for an absolute path (into a worktree) or
+  # one up from the cwd (`../lib/foo.rb` from a subdir), the longest PR
+  # path it ends with on a `/` boundary (see #worktree_suffix); else the
+  # one PR path that ends with +path+ (a bare `foo.rb`). nil: none, or
+  # several. A relative path that only ends with a PR path
+  # (`vendor/lib/foo.rb`) is another file.
   def resolve(files, path)
     path = path.sub(%r{\A(?:\./)+}, "")
     exact = files.find { |file| file.path == path } || files.find { |file| file.previous_path == path }
     return exact if exact
 
-    longer = files.select { |file| path.end_with?("/#{file.path}") }.max_by { |file| file.path.length }
-    return longer if longer
+    if path.start_with?("/", "~/", "../")
+      longer = files.select { |file| path.end_with?("/#{file.path}") }.sort_by { |file| -file.path.length }
+      return path.start_with?("../") ? longer.first : worktree_suffix(longer, path)
+    end
 
     shorter = files.select { |file| file.path.end_with?("/#{path}") }
     shorter.one? ? shorter.first : nil
   end
 
+  # The first of +files+ (longest path first) that the absolute +path+
+  # names inside a worktree: the part before the PR path is a directory
+  # with a `.git` (/abs/repo/vendor/lib/foo.rb is a vendored copy, not the
+  # PR's lib/foo.rb), or no directory here at all (a path from elsewhere;
+  # nothing to tell by). nil: each part before is a directory, none a
+  # worktree's root.
+  def worktree_suffix(files, path)
+    full = File.expand_path(path)
+    files.find do |file|
+      root = full.delete_suffix("/#{file.path}")
+      !File.directory?(root) || File.exist?(File.join(root, ".git"))
+    end
+  rescue ArgumentError
+    files.first
+  end
+
   # The PR's Files changed anchor when the lines are inside one hunk (the
   # new side; a removed file's old side), else the file at the PR's head
   # (a removed one: at its base), which has every line.

data/lib/samagotchi/bundles/system/config_modification_protocol.md

@@ -57,7 +57,7 @@ Only the nested form is read. An env name used as a top-level key (`SAMAGOTCHI_D
 **Excluded maps** (YAML-only, not part of the flat registry; skipped by scalar loader):
 
 - `model_aliases:` map of alias → model id (`ModelRef.parse`, through `HostRegistry#resolve`). Keys lowercased on write (`ConfigFile.write_model_alias!`). Values may be bare `model` or qualified `host:model` (hybrid; only `:` names a host, `org/model` is an id). Aliases apply once: never point an alias at another alias.
-- `hosts:` map of `name → {host, port | url, transport, api, api_key_env, profile, first_token_timeout, vision, sampling, thinking, enabled}` (`ConfigFile.hosts_config`, `host_registry.rb` `HostEntry`). Names lowercased; `url:` (http/https, optional path) replaces host/port, never both; `api_key_env:` names the env var holding the API key (never write a key into config.yml); `transport` overrides `server.transport`; `first_token_timeout` (seconds, `0` = off; a negative or non-number warns and is ignored) overrides `server.first_token_timeout` for that host; workers inherit via `SAMAGOTCHI_HOSTS_JSON` (`hosts_json_for_env`, `session_manager.rb`).
+- `hosts:` map of `name → {host, port | url, transport, api, api_key_env, profile, first_token_timeout, vision, sampling, thinking, enabled, models}` (`ConfigFile.hosts_config`, `host_registry.rb` `HostEntry`). Names lowercased; `url:` (http/https, optional path) replaces host/port, never both; `api_key_env:` names the env var holding the API key (never write a key into config.yml); `transport` overrides `server.transport`; `first_token_timeout` (seconds, `0` = off; a negative or non-number warns and is ignored) overrides `server.first_token_timeout` for that host; `models:` (a map of model ids, or a plain list) declares ids the host serves whatever its `/v1/models` lists: no "doesn't list" warning, and a bare id routes there as if listed (`HostModel`); an entry may hold `price: {input, output, cache_read?, cache_write?}` in USD per 1M tokens (`ModelPrice`; an unset cache rate is the input rate), which estimates a cost the provider doesn't report or reports as 0 (`cost_estimate`, shown as `~$`), and `served: [ids] | any`, the models a gateway may answer that id with (no served-model warning for them); model settings stay in the root `models:`; workers inherit via `SAMAGOTCHI_HOSTS_JSON` (`hosts_json_for_env`, `session_manager.rb`).
 - `models:` map of model id or alias → `{profile, vision, sampling, thinking}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: `--thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name on mlx, which has no template to read).
 - `hooks:` map of `hooks_dir` + per-event lists `{path, on_error}` (`Hooks::Loader.load`). `hooks_dir` may start with `~`.
 - `guardrails:` tool-call rules (`docs/guardrails.md`; read in `Engine#guardrail_rules`, parsed by `Guardrails::Rules.parse`): `enabled` (bool, default true; `false` drops rules and hooks' asks, a deny still applies; config.yml only, like every `guardrails` setting: no env variable), `parent_approvals` (`off`, the default: a parent agent's `chi answer` can only deny an approval; `once`: it may give "Allow once" too; a convention for an honest parent, not a security boundary, and the user's choice: set it only when the user asks), `rules:` (list), `disable:` (a rule id or a list of them, `id` or `bundle:id`, switching off a bundle's or config rule without editing it), `small_models` (`auto`, the default: small = 32B or less read from the name; a glob or list of globs; `[]` for none). A rule takes only `id`, `tool`, `command`, `path`, `git`, `models`, `verdict`, `reason`, `scopes`: `id` required; at least one of `tool` (a name, `shell` = execute + task_create, a `File.fnmatch` glob like `"mcp_*"`, or a list), `command` (a Ruby regex on the shell command), `path` (a glob, or `outside_repo`: outside the session's repo, tmp folders and memory files excepted), `git` (only `outside_repo`: a shell call runs commit/add/reset/… in another checkout); `models` (optional: `small`, a model-name glob, or a list; without it the rule is for every model); `verdict` `ask|deny`; `scopes` (for `ask`) a subset of `once, session, repo, rule`. **Any parse error (an unknown key, a bad regex, no verdict) makes chi deny every tool call** until fixed, so validate with `YAML.safe_load` and keep the list shape. Rules are read again on the next tool call after config.yml or a bundle's rules change: no restart needed. Installed bundles' rule files (`chi bundle install guardrails`) add to them; `/guardrails` lists what loaded.

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.45.0
+version: 0.46.1
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:dfc19266259a9af1e0d769b7e0f67996b740b0c9921fdf3dadad973f6e5c144a
-  config_modification_protocol.md: sha256:2d4135ce4fafcd391d1782dc3a54f7cbf10cd35ebe9f004b2d6cb256517a8451
+  config_modification_protocol.md: sha256:337ad1b4cc9308dc5abb47b13f51a76df4691ba80fe41648f391687b5b929b65
   memory_guide.md: sha256:15cd3b24eda853cc458371c6c75809a2d4b5352311d075aaa4384926b5221c27
   delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

data/lib/samagotchi/config.rb

@@ -10,6 +10,7 @@ require_relative "log"
 require_relative "model_ref"
 require_relative "paths"
 require_relative "llm_context_strategy"
+require_relative "host_model"
 
 module Samagotchi
   # Parses the thinking: levels of host and model entries (it needs Config).
@@ -263,10 +264,12 @@ module Samagotchi
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
       "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled
-                    remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens].freeze,
+                    remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
       "models" => %w[profile vision sampling thinking window_tokens llm_context_strategy llm_context_apply
                      llm_context_budget_tokens].freeze
     }.freeze
+    # The keys a hosts.<name>.models entry may hold (HostModel.parse_map).
+    HOST_MODEL_KEYS = %w[price served].freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
     SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze }.freeze
 
@@ -615,7 +618,33 @@ module Samagotchi
 
           (entry.keys.map(&:to_s) - allowed).map do |k|
             unknown_key_message("#{map}.#{name}.#{k}", k, allowed, prefix: "#{map}.#{name}.")
-          end
+          end + (map == "hosts" ? host_model_problems(name, entry["models"]) : [])
+        end
+      end
+
+      # hosts.<name>.models' entries, one level further down.
+      def host_model_problems(host, models)
+        return [] unless models.is_a?(Hash)
+
+        models.flat_map do |id, model|
+          next [] unless model.is_a?(Hash)
+
+          prefix = "hosts.#{host}.models.#{id}."
+          (model.keys.map(&:to_s) - HOST_MODEL_KEYS).map do |k|
+            unknown_key_message("#{prefix}#{k}", k, HOST_MODEL_KEYS, prefix: prefix)
+          end + price_key_problems("#{prefix}price.", model["price"])
+        end
+      end
+
+      # A price key's old name: the warning suggests the new one.
+      RENAMED_PRICE_KEYS = { "cached" => "cache_read" }.freeze
+
+      def price_key_problems(prefix, price)
+        return [] unless price.is_a?(Hash)
+
+        (price.keys.map(&:to_s) - ModelPrice::KEYS).map do |k|
+          # A renamed key is compared by its new name, so that name is the hint.
+          unknown_key_message("#{prefix}#{k}", RENAMED_PRICE_KEYS.fetch(k, k), ModelPrice::KEYS, prefix: prefix)
         end
       end
 
@@ -853,6 +882,7 @@ module Samagotchi
                                                  "hosts entry '#{name}'")
           llm_context_apply = LLMContextStrategy.parse_apply(raw_cfg.key?(LLMContextStrategy::APPLY_KEY) ? raw_cfg[LLMContextStrategy::APPLY_KEY] : raw_cfg[:llm_context_apply],
                                                              "hosts entry '#{name}'")
+          models = HostModel.parse_map(raw_cfg.key?("models") ? raw_cfg["models"] : raw_cfg[:models], name)
           llm_context_budget = LLMContextStrategy.parse_budget(raw_cfg.key?(LLMContextStrategy::BUDGET_KEY) ? raw_cfg[LLMContextStrategy::BUDGET_KEY] : raw_cfg[:llm_context_budget_tokens],
                                                                "hosts entry '#{name}'")
           unless first_token_timeout.nil? || (first_token_timeout.is_a?(Numeric) && !first_token_timeout.negative?)
@@ -920,8 +950,10 @@ module Samagotchi
                                   profile: profile.empty? ? nil : profile, first_token_timeout: first_token_timeout,
                                   vision: vision, sampling: sampling, thinking: thinking, remote: remote,
                                   window_tokens: window, llm_context_strategy: llm_context,
-                                  llm_context_apply: llm_context_apply, llm_context_budget_tokens: llm_context_budget }
+                                  llm_context_apply: llm_context_apply, llm_context_budget_tokens: llm_context_budget,
+                                  models: models }
         end
+        warn_duplicate_host_models(normalized)
       end
 
       # If no hosts defined, synthesize "default" from server.host/port/transport.
@@ -941,6 +973,30 @@ module Samagotchi
       {}
     end
 
+    # hosts.<name>.models as written back (HostModel#to_config), nil when none.
+    def host_models_config(models)
+      models.values.to_h { |m| [m.id, m.to_config] } unless models.nil? || models.empty?
+    end
+    private_class_method :host_models_config
+
+    # 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 warn_duplicate_host_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"
+        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_host_models
+
     # The names (lowercased) of the hosts entries with enabled: false, which
     # hosts_config leaves out. Read from the same source: config.yml's
     # hosts:, or SAMAGOTCHI_HOSTS_JSON in a worker.
@@ -1070,7 +1126,8 @@ module Samagotchi
                        "remote" => v[:remote], "window_tokens" => v[:window_tokens],
                        "llm_context_strategy" => v[:llm_context_strategy]&.map(&:to_s),
                        "llm_context_apply" => v[:llm_context_apply]&.to_s,
-                       "llm_context_budget_tokens" => v[:llm_context_budget_tokens]).compact
+                       "llm_context_budget_tokens" => v[:llm_context_budget_tokens],
+                       "models" => host_models_config(v[:models])).compact
       end
       # Disabled hosts travel as just that, so a worker refuses "box:x"
       # the way its parent does instead of sending it to the default host.

data/lib/samagotchi/desktop/macos/Panel.swift

@@ -980,6 +980,7 @@ final class PanelController: NSObject, NSWindowDelegate {
     let kittyText = windows.isEmpty ? "" : Kitty.text(context: model.hasContext ? model.text : "", message: model.trimmedPrompt,
                                                      imagePaths: ImageIntake.keepForPaste(images), pasteOnly: kind == .paste)
 
+    let open = opens
     let group = DispatchGroup()
     var chiOutcome: SendOutcome?
     var kittyOutcomes: [(KittyWindow, KittyError?)] = []
@@ -1004,6 +1005,9 @@ final class PanelController: NSObject, NSWindowDelegate {
       // another try, unless the panel was closed or reopened meanwhile.
       if ok { self.model.images.removeAll { images.contains($0) } }
       ImageIntake.delete(images.filter { !self.model.images.contains($0) })
+      // Reopened meanwhile (as for a broadcast): the new open keeps its
+      // message and phase, and isn't closed by this send's success.
+      guard self.opens == open else { return }
       var parts: [String] = []
       if let chiOutcome { parts.append(chiOutcome.message) }
       if !pasted.isEmpty {
@@ -1014,7 +1018,7 @@ final class PanelController: NSObject, NSWindowDelegate {
       if ok {
         self.model.phase = .sent
         DispatchQueue.main.asyncAfter(deadline: .now() + (chiOutcome?.linger ?? 1.0)) { [weak self] in
-          if self?.model.phase == .sent { self?.panel.close() }
+          if self?.opens == open, self?.model.phase == .sent { self?.panel.close() }
         }
       } else {
         self.model.phase = .failed
@@ -1022,8 +1026,8 @@ final class PanelController: NSObject, NSWindowDelegate {
     }
   }
 
-  /// Counts the panel's opens: a broadcast that ends after a reopen leaves
-  /// the new open alone.
+  /// Counts the panel's opens: a send or broadcast that ends after a
+  /// reopen leaves the new open alone.
   private var opens = 0
 
   /// The Everyone row: `chi broadcast` with the note (the source field is

data/lib/samagotchi/engine.rb

@@ -945,13 +945,16 @@ module Samagotchi
     # context window, the served model and (on a native host) the prompt
     # profile come from the effective model's server, so this may make one
     # short /props GET; the cheap #session_state_snapshot never does.
+    # price_host: the effective model's host, whose hosts.<name>.models
+    # prices the cost estimate names.
     # @return [Hash] @metrics.snapshot, filled in
     def stats_snapshot
       snapshot = @metrics.snapshot
       target = @host_registry.resolve(@effective_model_name)
       served, served_for = served_model_for(snapshot, target: target)
-      snapshot = snapshot.merge(served_model: served, served_model_for: served_for, llm_context: llm_context_summary,
-                                prompt_notes: prompt_notes.map(&:to_h))
+      snapshot = snapshot.merge(served_model: served, served_model_for: served_for,
+                                served_expected_by: served_expected_by(served, target: target), llm_context: llm_context_summary,
+                                prompt_notes: prompt_notes.map(&:to_h), price_host: target.entry.name)
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
         if window
@@ -1045,6 +1048,18 @@ module Samagotchi
       served_model_for(@metrics.served_report, target: probe ? @host_registry.resolve(@effective_model_name) : nil)
     end
 
+    # The host whose hosts.<name>.models.<id>.served names +served+ for the
+    # current model (a gateway's round-robin targets): not a mismatch to
+    # warn about. nil when none does.
+    # @return [String, nil]
+    def served_expected_by(served, target: nil)
+      ServedModel.expected_by(target || @host_registry.resolve(@effective_model_name), served)
+    rescue StandardError
+      nil
+    end
+
+    def served_expected?(served) = !served_expected_by(served).nil?
+
     # Read-only snapshot of the engine's view of the current session plus the
     # live event sequence. Cheap primitive used by the bridge's reconnect-too-
     # old reset marker and the GET /session/:id/state read surface. Orthogonal
@@ -1065,6 +1080,8 @@ module Samagotchi
     #   :served_model, :served_model_for [String, nil] what a generation of
     #     that model reported serving, and the name asked (#served_model
     #     without the probe)
+    #   :served_expected_by [String, nil] the host whose models: entry names
+    #     that served model under served: (#served_expected_by)
     #   :recap_enabled [Boolean]   whether an idle recap is configured, with
     #     :recap_min_user_turns and :recap_inactivity_seconds (nil when not)
     def session_state_snapshot
@@ -1085,6 +1102,7 @@ module Samagotchi
         model_name: effective_model_ref,
         served_model: served_pair[0],
         served_model_for: served_pair[1],
+        served_expected_by: served_expected_by(served_pair[0]),
         context_status: @last_context_status&.dup || saved_context_status(metrics[:context]),
         llm_context: llm_context_summary,
         recap_enabled: !@recap.nil?,
@@ -1430,8 +1448,6 @@ module Samagotchi
       @question_desk.request(payload)
     end
 
-    QUESTION_DISMISSED_NOTE = QuestionDesk::DISMISSED_NOTE
-
     # Open a question for the UIs and wait for its answer
     # (QuestionDesk#open_question: BLOCKS until answered or cancelled).
     # @param fields [Hash] question:, options:, header:, multi_select:, allow_freeform:, …
@@ -1824,7 +1840,7 @@ module Samagotchi
       @turn_thinking = [thinking_level(thinking_target), thinking_target]
       announce_thinking_level(*@turn_thinking)
       LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first, model_name: nil,
-                            window_setting: nil, llm_context: nil)
+                            window_setting: nil, llm_context: nil, price: nil)
     end
     private :turn_settings
 
@@ -1918,7 +1934,7 @@ module Samagotchi
       # turn's model, not the last native one.
       explained = llm_context_explained
       @kernel.turn_settings = turn.settings.with(model_name: bare_for_backend, window_setting: turn_window_setting,
-                                                 llm_context: explained&.resolved)
+                                                 llm_context: explained&.resolved, price: turn_price)
       log_llm_context(explained)
 
       turn.limit = @no_interrupt ? IterationLimit.for(no_interrupt: true) : max_iterations || IterationLimit.for
@@ -2549,6 +2565,12 @@ module Samagotchi
         when :generation_started
           @generation_thought = nil
           watch&.started(event[:iteration])
+        when :generation_retrying
+          # A dropped stream's step asked again: it streams from the start.
+          if event[:restarted]
+            @generation_thought = nil
+            watch&.started(event[:iteration])
+          end
         when :generation_chunk then note_generation_thought(progress[:thinking])
         end
         # The chat loop asked again without the thinking fields: a notice,
@@ -2566,13 +2588,14 @@ module Samagotchi
     end
 
     # A :generation_completed with the generation's decode speed (`speed:`
-    # {decode_tps:, source:}, nil without one) and the session's running
-    # token totals (`tokens:`, the snapshot's block): the web's info bar
+    # {decode_tps:, source:}, nil without one), the session's running
+    # token totals (`tokens:`, the snapshot's block) and whether its served
+    # model is an expected one (`served_expected_by:`, its host): the web's info bar
     # reads them from the stream. SessionMetrics closes the generation here,
     # so the event it gets next finds it closed.
     def with_generation_report(event)
       report = @metrics.finish_generation
-      event.merge(speed: report.speed&.to_h, tokens: report.tokens)
+      event.merge(speed: report.speed&.to_h, tokens: report.tokens, served_expected_by: served_expected_by(event[:served_model]))
     rescue StandardError
       event
     end
@@ -2638,6 +2661,15 @@ module Samagotchi
       nil
     end
 
+    # The effective model's price on its host (hosts.<name>.models.<id>.price),
+    # by the requested id, never the served one; read per turn as the window is.
+    def turn_price
+      target = @host_registry.resolve(@effective_model_name)
+      target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.price
+    rescue StandardError
+      nil
+    end
+
     # The LLM context strategy the next turn runs under: the session's own
     # (Session#llm_context), else the effective model's (models:/hosts:
     # llm_context_strategy), else llm_context.strategy; read per turn as

data/lib/samagotchi/host_model.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "model_price"
+
+module Samagotchi
+  # A model a host serves, declared under hosts.<name>.models: whatever the
+  # host's /v1/models says (a gateway's round-robin ids it never lists). A
+  # declared id is known on its host: no "doesn't list" warning, no re-list,
+  # and a bare id routes there as if the host listed it
+  # (HostRegistry#host_for_model).
+  #
+  # id: the id as written (keys are matched downcased); price: its
+  # ModelPrice on this host, nil when none; served: the models the host may
+  # answer it with (a gateway's round-robin targets), exact ids as written
+  # or "any", nil when none: no served-model warning for those (#serves?).
+  HostModel = Data.define(:id, :price, :served) do
+    def initialize(id:, price: nil, served: nil) = super
+
+    # hosts.<name>.models as written: a map of ids (each nil or a map), or
+    # a plain list of ids. Anything else warns once and is skipped.
+    # @param raw [Hash, Array, nil]
+    # @param host_name [String] for the warnings
+    # @return [Hash{String => HostModel}] by downcased id, in written order
+    def self.parse_map(raw, host_name)
+      return {} if raw.nil?
+
+      where = "hosts.#{host_name}.models"
+      pairs = case raw
+              when Hash then raw.to_a
+              when Array then raw.map { |id| [id, nil] }
+              else
+                warn_once "Warning: #{where} must be a map or a list of model ids; ignored"
+                return {}
+              end
+      pairs.each_with_object({}) do |(id, entry), models|
+        id = id.to_s.strip if id.is_a?(String) || id.is_a?(Symbol)
+        unless id.is_a?(String) && !id.empty?
+          warn_once "Warning: #{where}: #{id.inspect} is not a model id; ignored"
+          next
+        end
+        unless entry.nil? || entry.is_a?(Hash)
+          warn_once "Warning: #{where}.#{id} must be empty or a mapping; ignored"
+          next
+        end
+        value = ->(key) { entry && (entry.key?(key) ? entry[key] : entry[key.to_sym]) }
+        price = ModelPrice.parse(value.call("price"), "#{where}.#{id}")
+        models[id.downcase] ||= new(id: id, price: price, served: parse_served(value.call("served"), "#{where}.#{id}"))
+      end
+    end
+
+    # served: a list of ids, or "any"; anything else warns once and is unset.
+    def self.parse_served(raw, where)
+      return nil if raw.nil?
+      return "any" if raw.is_a?(String) && raw.strip.casecmp?("any")
+
+      ids = raw.is_a?(Array) && raw.all? { |id| id.is_a?(String) && !id.strip.empty? } ? raw.map(&:strip) : nil
+      warn_once "Warning: #{where}.served must be a list of model ids or any; ignored" unless ids
+      ids
+    end
+    private_class_method :parse_served
+
+    # Whether the host answering this model with +name+ is expected
+    # (served: lists it, any case, or says any).
+    def serves?(name)
+      return false if served.nil? || name.to_s.strip.empty?
+
+      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
+    private_class_method :warn_once
+
+    # One host's rows as the listings show them, declared ids first, then
+    # the listed ones in the host's order (see Row). An id both declared and
+    # listed is one row. Pure: +results+ (list_all_models') is only read.
+    # A host that errored keeps only its declared ids, marked unavailable
+    # (still pickable; the listings warn it's unreachable); [] when it
+    # declares none.
+    # @param results [Hash{String => Hash}] host name => {models: [ModelInfo], error:}
+    # @param entries [Hash{String => HostRegistry::HostEntry}]
+    # @return [Hash{String => Array<Row>}] for every host in +results+
+    def self.rows(results, entries)
+      results.each_with_object({}) do |(name, data), out|
+        declared = entries[name]&.models || {}
+        if data[:error]
+          out[name] = declared.values.map { |m| HostModel::Row.new(id: m.id, configured: true, info: nil, unavailable: true) }
+          next
+        end
+
+        infos = Array(data[:models])
+        by_id = infos.group_by { |info| info.id.to_s.downcase }
+        out[name] = declared.values.map do |m|
+          info = by_id[m.id.downcase]&.first
+          # A listed id keeps the host's spelling: a case-sensitive server takes only that.
+          HostModel::Row.new(id: info ? info.id.to_s : m.id, configured: true, info: info)
+        end +
+                    infos.reject { |info| declared.key?(info.id.to_s.downcase) }
+                         .map { |info| HostModel::Row.new(id: info.id.to_s, configured: false, info: info) }
+      end
+    end
+
+    # The entry as written back to config (SAMAGOTCHI_HOSTS_JSON for
+    # workers): nil for a bare id.
+    def to_config
+      config = { "price" => price&.to_config, "served" => served }.compact
+      config unless config.empty?
+    end
+  end
+
+  # A listing row (HostModel.rows): id as the host lists it, else as
+  # declared;
+  # configured: declared under hosts.<name>.models; info: the host's
+  # ModelInfo for it, nil when only declared; unavailable: the host failed
+  # to list its models; only its declared ids are shown.
+  HostModel::Row = Data.define(:id, :configured, :info, :unavailable) do
+    def initialize(id:, configured:, info:, unavailable: false) = super
+  end
+end

data/lib/samagotchi/host_registry.rb

@@ -39,10 +39,12 @@ module Samagotchi
     # window_tokens: the configured context window (ContextWindow.setting), nil when unset;
     # llm_context_strategy: the configured layers (LLMContextStrategy), nil when unset;
     # llm_context_apply: the configured apply rule (LLMContextStrategy), nil when unset;
-    # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset.
+    # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
+    # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
     HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
-                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, keyword_init: true) do
+                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, :models,
+                           keyword_init: true) do
       # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
       # raw-prompt loop.
       def chat? = api == :openai
@@ -104,7 +106,7 @@ module Samagotchi
                               vision: cfg[:vision], sampling: cfg[:sampling], thinking: cfg[:thinking],
                               remote: cfg[:remote], window_tokens: cfg[:window_tokens],
                               llm_context_strategy: cfg[:llm_context_strategy], llm_context_apply: cfg[:llm_context_apply],
-                              llm_context_budget_tokens: cfg[:llm_context_budget_tokens])
+                              llm_context_budget_tokens: cfg[:llm_context_budget_tokens], models: cfg[:models] || {})
         entry.client = Client.new(host: cfg[:host], port: cfg[:port], transport: transport, scheme: cfg[:scheme],
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
                                   api_key_env: entry.api_key_env, env: env)
@@ -116,7 +118,8 @@ module Samagotchi
         host = "localhost" if host.empty?
         port = Config.get("server.port").to_i
         port = 8080 if port <= 0
-        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, transport: nil, client: Client.new(host: host, port: port, name: "default"))
+        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, transport: nil, models: {},
+                                            client: Client.new(host: host, port: port, name: "default"))
       end
       @mutex = Mutex.new
       @cache = nil
@@ -195,18 +198,21 @@ module Samagotchi
 
     # The host a model name, alias or host:model ref goes to and the model
     # id it is sent as (ModelRef: one alias pass). A ref that names a host
-    # goes there. A bare id goes to the default host when its cached list
-    # has it, else to the first host in hosts: order whose list has it,
-    # else to the default host (before /models nothing is listed: no
+    # goes there. A bare id goes to the hosts whose cached list has it or
+    # that declare it (hosts.<name>.models, known before any /models): the
+    # default host when it is one of them, else the first in hosts: order,
+    # else the default host (before /models nothing is listed: no
     # discovery here, the latency budget). Never by a substring.
     def host_for_model(raw_model)
       ref = model_ref(raw_model)
       # ModelRef names a host only when it is one of ours
       return [find_entry(ref.host_name), ref.id] if ref.host_name
 
-      listed = @mutex.synchronize { @model_index }&.fetch(ref.id.to_s.strip.downcase, nil) || []
+      down = ref.id.to_s.strip.downcase
+      listed = @mutex.synchronize { @model_index }&.fetch(down, nil) || []
+      candidates = @entries.values.select { |e| listed.include?(e.name) || e.models&.key?(down) }.map(&:name)
       default = default_entry
-      name = listed.include?(default.name) ? default.name : listed.first
+      name = candidates.include?(default.name) ? default.name : candidates.first
       [(name && find_entry(name)) || default, ref.id]
     end
 
@@ -316,7 +322,7 @@ module Samagotchi
             save_model_list(name, models)
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
-            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: e.message }
+            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: list_error(e) }
           end
           results_mutex.synchronize { results[name] = data }
         end
@@ -368,6 +374,11 @@ module Samagotchi
 
     private
 
+    # A listing error as text without the host's name (a provider error's
+    # #detail: "connection refused", "request failed after …"): every line
+    # that shows it names the host itself.
+    def list_error(error) = error.is_a?(LLM::ProviderError) ? error.detail : error.message
+
     # Save a host's just-listed models on disk, for the processes that spawn
     # a worker without listing (`chi send --new --model`, delegate):
     # ModelListStore is what they check an id against.

data/lib/samagotchi/kernel_loop.rb

@@ -353,7 +353,8 @@ module Samagotchi
       # thought or a tool call doesn't leave the next one "inside" it.
       stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
       emit(turn, type: :generation_started, iteration: turn.iteration, context_window_tokens: request.window.tokens,
-                 context_window_source: request.window.source, profile: @profile.name, profile_source: @profile_source)
+                 context_window_source: request.window.source, profile: @profile.name, profile_source: @profile_source,
+                 price: @turn_settings.price&.to_h)
       # This generation's own server counts (the run-long ones in the
       # context tracker can be an earlier one's), and the thinking it
       # streamed, for the log (a stuck thinking generation shows as