samagotchi 0.45.0 → 0.46.1

data/lib/samagotchi/llm/chat_loop.rb

@@ -54,10 +54,49 @@ module Samagotchi
       #   per turn for the effective model's host
       # @param stable_length [#call, nil] text → the length of the system
       #   prompt's part every session shares (SystemPrompt#stable_length), or nil
-      def initialize(kernel:, adapter: nil, stable_length: nil)
+      # @param sleeper [#call, nil] waits the given seconds before a dropped
+      #   stream's step is asked again (specs pass one that doesn't sleep)
+      def initialize(kernel:, adapter: nil, stable_length: nil, sleeper: nil)
         @kernel = kernel
         @adapter = adapter
         @stable_length = stable_length
+        @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+      end
+
+      # How many times a dropped stream's step may be asked again: +cap+, or
+      # retry.max when that is smaller (retry.max: 0 turns it off, as it
+      # does the transport's retries).
+      def stream_drop_limit(cap)
+        [cap, HTTP::RetryPolicy.from_config.max].min
+      rescue StandardError
+        cap
+      end
+
+      # The seconds before the +attempt+-th ask-again of a dropped stream's
+      # step: the transport's own backoff (retry.base_delay doubling, capped
+      # at retry.max_delay; LLM::HTTP::RetryPolicy), 0 when retry.max is
+      # spent.
+      def generation_retry_delay(attempt)
+        HTTP::RetryPolicy.from_config.delay_for(attempt) || 0.0
+      rescue StandardError
+        0.0
+      end
+
+      # Waits +seconds+ in short slices, raising RequestCancelled as soon as
+      # one of +controllers+ (the turn's, the generation's) is cancelled, as
+      # LLM::HTTP's own wait between retries does.
+      def wait_retry(seconds, *controllers)
+        remaining = seconds.to_f
+        while remaining.positive?
+          cancelled = controllers.compact.find(&:cancelled?)
+          raise RequestCancelled, cancelled.reason if cancelled
+
+          slice = [remaining, 0.05].min
+          @sleeper.call(slice)
+          remaining -= slice
+        end
+        cancelled = controllers.compact.find(&:cancelled?)
+        raise RequestCancelled, cancelled.reason if cancelled
       end
 
       def provider = :chat
@@ -180,6 +219,9 @@ module Samagotchi
       # turn_settings), or nil.
       def vision = @kernel.turn_settings.vision
 
+      # The turn's configured price (the kernel's turn_settings), or nil.
+      def price = (@kernel.turn_settings&.price if @kernel.respond_to?(:turn_settings))
+
       # The turn's request parameters (the kernel's turn_settings).
       def sampling = @kernel.turn_settings.sampling || {}
 
@@ -461,20 +503,25 @@ module Samagotchi
           observe_context(iteration, window)
           retry_generation = @empty_retry.take_sampling!
           emit(type: :generation_started, iteration: iteration, context_window_tokens: window&.tokens,
-               context_window_source: window&.source)
+               context_window_source: window&.source, price: @loop.price&.to_h)
           @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
           streamed = +""
           thought = +""
-          response = with_generation do |generation_controller|
+          generation_controller = nil
+          response = with_generation do |controller|
+            generation_controller = controller
+            # One count for the step: the ask-again without thinking fields
+            # doesn't get drops of its own.
+            drops = DropCount.new(0, 0)
             begin
-              request(iteration, retry_generation, streamed, thought, generation_controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
             rescue BadRequest => e
               raise unless thinking_refused?(e)
 
               # Once per model: asked again without the thinking fields.
               @loop.thinking_refused!(@model_name)
               emit(type: :thinking_refused, iteration: iteration, model: @model_name, level: @loop.thinking, detail: e.detail)
-              request(iteration, retry_generation, streamed, thought, generation_controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
             end
           rescue RequestCancelled
             raise unless generation_controller&.cancelled? && !@cancel_controller.cancelled?
@@ -522,7 +569,7 @@ module Samagotchi
           [response, nil]
         end
 
-        def request(iteration, retry_generation, streamed, thought, generation_controller)
+        def request(iteration, retry_generation, streamed, thought, generation_controller, streamed_any = nil)
           @loop.adapter.chat(
             messages: @loop.wire_messages(@conversation), tools: @loop.tool_definitions, model: @model_name,
             cancel_controller: generation_controller || @cancel_controller, session_id: @loop.session_id,
@@ -533,13 +580,68 @@ module Samagotchi
               event = { type: :generation_chunk, iteration: iteration, content: reasoning + content, text: content,
                         thinking: reasoning, payload: payload }
               # A tool call streaming: a steer doesn't cut it (Engine#cut_for_steer).
-              event[:tool_call] = true if OpenAIChat.tool_call_delta?(payload)
+              tool_call = OpenAIChat.tool_call_delta?(payload)
+              event[:tool_call] = true if tool_call
+              streamed_any&.call if !content.to_s.empty? || !reasoning.to_s.empty? || tool_call
               emit(event)
             },
             on_retry: ->(**retry_event) { emit({ type: :generation_retrying, iteration: iteration }.merge(retry_event)) }
           )
         end
 
+        # A dropped stream (LLM::HTTP raises RetryExhausted once a stream
+        # that already showed something fails, where a retry would repeat
+        # output) is asked again here, from the same conversation, up to
+        # MAX_STREAM_DROPS times per step (fewer under a smaller retry.max;
+        # none with 0), after the transport's backoff: the partial reply is
+        # dropped and the step restarts. A refusal or a first-token timeout
+        # fails as before, and a cancel (before or during the wait) never
+        # retries.
+        MAX_STREAM_DROPS = 2
+
+        # A step's drops asked again (+drops+) and the HTTP requests made so
+        # far (+requests+: each failed request's transport attempts), so the
+        # error that ends the step counts every request, not the last one's.
+        DropCount = Struct.new(:drops, :requests)
+
+        # Runs one request, asking again on a mid-stream drop; +count+ (a
+        # DropCount) carries on across calls for one step.
+        def request_with_drops(iteration, retry_generation, streamed, thought, count, generation_controller)
+          streamed_any = false
+          request(iteration, retry_generation, streamed, thought, generation_controller, -> { streamed_any = true })
+        rescue RetryExhausted => e
+          # A cancel that landed as the stream dropped ends the turn canceled,
+          # not failed, whatever the drop's count.
+          cancelled = [@cancel_controller, generation_controller].compact.find(&:cancelled?)
+          raise RequestCancelled, cancelled.reason if cancelled
+
+          count.requests += e.attempts.to_i
+          limit = @loop.stream_drop_limit(MAX_STREAM_DROPS)
+          if count.drops >= limit || !streamed_any
+            raise if count.requests == e.attempts.to_i
+
+            raise RetryExhausted.new(attempts: count.requests, last_error: e.last_error, label: e.host)
+          end
+
+          count.drops += 1
+          attempt = count.drops
+          streamed.clear
+          thought.clear
+          delay = @loop.generation_retry_delay(attempt)
+          # restarted: the step's streamed chunks so far are void (the UIs
+          # and the Bridge's TurnAccumulator drop them).
+          emit(type: :generation_retrying, iteration: iteration, attempt: attempt, max_retries: limit,
+               next_delay: delay, error_class: e.class.name, error_message: e.message, status: nil, restarted: true)
+          @loop.wait_retry(delay, @cancel_controller, generation_controller)
+          retry
+        rescue ProviderError => e
+          # Another failure (a 503, a refusal) after earlier requests this
+          # step: its count takes theirs in.
+          count.requests += e.attempts.to_i
+          e.attempts = count.requests
+          raise
+        end
+
         # A 400 about reasoning, for a request that carried thinking fields
         # (not a missing-tools, image or context error).
         def thinking_refused?(error)

data/lib/samagotchi/llm/errors.rb

@@ -223,11 +223,17 @@ module Samagotchi
 
       def initialize(attempts:, last_error:, label: "llama.cpp")
         @last_error = last_error
-        super("#{label} request failed after #{attempts} attempts: #{last_error.class}: #{last_error.message}",
+        super("#{label} request failed after #{self.class.count(attempts)}: #{last_error.class}: #{last_error.message}",
               host: label, retryable: false, attempts: attempts)
       end
 
-      def summary = "network error after #{attempts} attempts (host #{host}: #{last_error.class})"
+      def summary = "network error after #{self.class.count(attempts)} (host #{host}: #{last_error.class})"
+
+      # The message without its leading "host ": "request failed after …".
+      def detail = host ? message.delete_prefix("#{host} ") : message
+
+      # "1 attempt", "3 attempts".
+      def self.count(attempts) = "#{attempts} attempt#{"s" unless attempts == 1}"
     end
 
     # A refused connection: nothing listens at the host's address. Not

data/lib/samagotchi/llm/turn_settings.rb

@@ -11,12 +11,14 @@ module Samagotchi
     # (Thinking.resolve), the bare model id the turn runs on (every debug
     # dump is tagged with it) and the model's or host's configured context
     # window (ContextWindow.setting, nil for none) and LLM context strategy
-    # (LLMContextStrategy.resolve, nil for none). The Engine sets them once
+    # (LLMContextStrategy.resolve, nil for none), and its price on its host
+    # (hosts.<name>.models.<id>.price, a ModelPrice; nil for none), what
+    # SessionMetrics estimates an unreported cost from. The Engine sets them once
     # per turn, in Engine#generate, after the model's host is synced.
-    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name, :window_setting, :llm_context) do
+    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name, :window_setting, :llm_context, :price) do
       # No vision, no sampling, the default thinking, no model name.
       def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil,
-                          window_setting: nil, llm_context: nil)
+                          window_setting: nil, llm_context: nil, price: nil)
     end
   end
 end

data/lib/samagotchi/llm_context_strategy.rb

@@ -181,6 +181,7 @@ module Samagotchi
       return nil if session.nil?
 
       require_relative "config"
+      require_relative "model_profile"
       registry ||= begin
         require_relative "host_registry"
         HostRegistry.new

data/lib/samagotchi/model_catalog.rb

@@ -7,33 +7,36 @@ module Samagotchi
   # picks from: GET /api/models and `chi models`. Every name question goes
   # to ModelRef / HostRegistry#resolve; nothing here parses a ref.
   module ModelCatalog
-    # host: the host that listed the id; ref: the name `--model` takes for
-    # it (see .spell).
-    Row = Data.define(:host, :id, :ref)
-    # rows: the default host's first, then the others by name; warnings:
-    # "host: error" per host that failed.
+    # host: the host that listed (or declares) the id; ref: the name
+    # `--model` takes for it (see .spell); configured: declared under
+    # hosts.<name>.models (HostModel.rows); unavailable: a declared id of a
+    # host that failed to list its models (still pickable).
+    Row = Data.define(:host, :id, :ref, :configured, :unavailable) do
+      def initialize(host:, id:, ref:, configured: false, unavailable: false) = super
+    end
+    # rows: the default host's first, then the others by name, each host's
+    # declared ids first (HostModel.rows; a host that failed keeps only
+    # those); warnings: "host: error" per host that failed.
     Listing = Data.define(:rows, :warnings)
 
     module_function
 
     # @param results [Hash] list_all_models' answer
-    # @param registry [#default_entry]
+    # @param registry [#default_entry, #entries]
     # @return [Listing]
     def listing(results, registry:)
       default_host = registry.default_entry&.name
       rows = []
       warnings = []
+      host_rows = HostModel.rows(results, registry.entries)
       results.keys.sort_by { |name| [name == default_host ? 0 : 1, name] }.each do |host|
-        data = results[host]
-        if data[:error]
-          warnings << "#{host}: #{data[:error]}"
-          next
-        end
-        Array(data[:models]).each do |info|
-          id = info.id.to_s
-          next if id.strip.empty? || id.end_with?(":batch")
+        warnings << "#{host}: #{results[host][:error]}" if results[host][:error]
+        host_rows.fetch(host, []).each do |row|
+          id = row.id
+          next if id.strip.empty? || (!row.configured && id.end_with?(":batch"))
 
-          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host))
+          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host), configured: row.configured,
+                          unavailable: row.unavailable)
         end
       end
       Listing.new(rows: rows, warnings: warnings)
@@ -51,13 +54,16 @@ module Samagotchi
     # go first (its rows are the "default host" group). default: the default's listed
     # row name when it resolves to one, else its resolved ref; default_typed:
     # the alias it was typed as. A row whose name resolves elsewhere (an
-    # alias named like the id shadows it) carries shadowed_by.
+    # alias named like the id shadows it) carries shadowed_by; a declared id
+    # of a host that failed to list carries unavailable.
     # @param default_name [String, nil] default.model as configured
     # @return [Hash]
     def payload(results, registry:, default_name:)
       listing = listing(results, registry: registry)
       models = listing.rows.map do |row|
         hash = { name: row.ref, host: row.host, id: row.id }
+        hash[:configured] = true if row.configured
+        hash[:unavailable] = true if row.unavailable
         shadow = shadowed_by(row, registry)
         shadow ? hash.merge(shadowed_by: shadow) : hash
       end

data/lib/samagotchi/model_price.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A model's price on a host (hosts.<name>.models.<id>.price), in USD per
+  # 1M tokens: what a generation's cost is estimated from when the provider
+  # reports none (SessionMetrics, cost_estimate). An unset cache rate is the
+  # input rate: that overstates cached reads, and understates Anthropic
+  # cache writes (billed 1.25x input for the 5 min cache, 2x for 1 h).
+  ModelPrice = Data.define(:input, :cache_read, :cache_write, :output) do
+    # @param raw [Hash, nil] the price as written
+    # @param where [String] for the warning
+    # @return [ModelPrice, nil] nil when unset or invalid (warned once)
+    def self.parse(raw, where)
+      return nil if raw.nil?
+
+      values = raw.is_a?(Hash) ? raw.transform_keys(&:to_s).slice(*ModelPrice::KEYS) : nil
+      valid = values && values.key?("input") && values.key?("output") &&
+              # YAML's .inf and .nan are Floats too: JSON can't carry them
+              # (hosts_json_for_env would drop every host) and NaN poisons the sums.
+              values.values.all? { |v| v.is_a?(Numeric) && v.finite? && !v.negative? }
+      unless valid
+        warn_once "Warning: #{where}.price needs input and output, each a number >= 0 (USD per 1M tokens); ignored"
+        return nil
+      end
+      new(input: values["input"], cache_read: values.fetch("cache_read", values["input"]),
+          cache_write: values.fetch("cache_write", values["input"]), output: values["output"])
+    end
+
+    # config.rb requires model_price through host_model, so config is
+    # required here only when a warning needs it.
+    def self.warn_once(message)
+      require_relative "config"
+      ConfigFile.warn_once(message)
+    end
+    private_class_method :warn_once
+
+    # USD for one generation, OpenAI usage semantics: +prompt_tokens+ holds
+    # the cached reads and the cache writes (OpenRouter keeps that for
+    # Anthropic models), and reasoning is inside +completion_tokens+.
+    # llama.cpp's native timings.prompt_n leaves its cache_n out, so the
+    # uncached part is clamped at 0: an undercount, harmless because priced
+    # models are remote.
+    def cost(prompt_tokens:, cached_tokens:, cache_write_tokens:, completion_tokens:)
+      uncached = (prompt_tokens - cached_tokens - cache_write_tokens).clamp(0..)
+      ((uncached * input) + (cached_tokens * cache_read) + (cache_write_tokens * cache_write) +
+       (completion_tokens * output)) / 1e6
+    end
+
+    def to_config = to_h.transform_keys(&:to_s)
+  end
+
+  # The keys a price may hold (config validation checks them too).
+  ModelPrice::KEYS = %w[input cache_read cache_write output].freeze
+end

data/lib/samagotchi/model_profile.rb

@@ -190,7 +190,7 @@ module Samagotchi
     #
     # Only a ref that names a host is checked (its alias resolved first, as
     # ModelRef.parse does), and only against that host's own list: a bare id
-    # goes to whichever host lists it (HostRegistry#host_for_model), so no
+    # goes to whichever host lists or declares it (HostRegistry#host_for_model), so no
     # single list can judge it. Nothing is checked either without a saved
     # list for the host or with one older than ModelListStore::TTL_SECONDS
     # (a week: the host may serve different models by now).
@@ -219,6 +219,8 @@ module Samagotchi
       parsed = Samagotchi::ConfigFile.model_ref(model_name, env: env, hosts: hosts)
       host = parsed.host_name
       return nil unless host
+      # Declared under hosts.<name>.models: served whatever the host lists.
+      return nil if hosts[host.to_s.strip.downcase]&.dig(:models)&.key?(parsed.id.to_s.strip.downcase)
 
       list = lists.read(env: env)[host.to_s.strip.downcase]
       return nil if list.nil? || list.stale? || list.known?(parsed.id)
@@ -230,10 +232,11 @@ module Samagotchi
       return unknown_model_message(parsed.id, host, list.ids) if list.age < RELIST_AFTER_SECONDS
 
       fresh_ids = relist_or_nil(relist || default_relist(hosts), host, env)
-      # A re-list that answered: the saved list catches up (the default
-      # re-list, HostRegistry#list_models, saved it already).
+      # A re-list that answered: the saved list catches up. The default
+      # re-list, HostRegistry#list_models, saved it already; a given one
+      # is saved here.
       if fresh_ids
-        Samagotchi::ModelListStore.save(host, fresh_ids, env: env)
+        Samagotchi::ModelListStore.save(host, fresh_ids, env: env) if relist
         return nil if fresh_ids.any? { |id| id.to_s.casecmp?(parsed.id.to_s.strip) }
 
         return unknown_model_message(parsed.id, host, fresh_ids)

data/lib/samagotchi/models_command.rb

@@ -23,13 +23,14 @@ module Samagotchi
         Lists the models every configured host offers, as the names
         --model takes: the default first, a default-host id bare, another
         host's as host:id, then the aliases as "name -> ref". A host that
-        fails or doesn't answer in time is noted on stderr.
+        fails or doesn't answer in time is noted on stderr; the ids
+        declared under its hosts.<name>.models are still listed.
         TEXT          only the names containing it (any case)
         --format json the default, the models (host, id, name), the aliases
                       and the warnings as one JSON object
         --timeout S   wait at most S seconds for the hosts; default 4
         Exit 0 when any host listed its models, 1 when none did (the
-        default is still printed), 2 on a usage error.
+        default and declared names still print), 2 on a usage error.
     TEXT
 
     FLAGS = CLI::Flags.new(help: CLI::Command::HELP_WORDS) do |f|
@@ -59,8 +60,10 @@ module Samagotchi
       return usage_error("--timeout takes a number of seconds above 0") unless timeout&.positive?
 
       payload, listed = catalog(timeout)
+      # Before the filter: a down host's declared ids are listed even when TEXT hides them.
+      down_hosts = payload[:models].select { |m| m[:unavailable] }.map { |m| m[:host] }.uniq
       payload = filtered(payload, parsed.args.join(" ").strip)
-      options[:format] == "json" ? print_json(payload) : print_text(payload)
+      options[:format] == "json" ? print_json(payload) : print_text(payload, down_hosts)
       listed ? 0 : 1
     end
 
@@ -99,14 +102,18 @@ module Samagotchi
       @stdout.puts(JSON.generate(payload.except(:filter)))
     end
 
-    def print_text(payload)
+    # @param down_hosts [Array<String>] hosts that failed but declare ids
+    def print_text(payload, down_hosts)
       default = payload[:default]
       names = payload[:models].reject { |m| m[:shadowed_by] }.map { |m| m[:name] }
       shown_default = default && (payload[:filter].nil? || default.downcase.include?(payload[:filter].downcase))
       @stdout.puts(default) if shown_default
       (names - [default]).each { |name| @stdout.puts(name) }
       payload[:aliases].each { |a| @stdout.puts("#{a[:name]} -> #{a[:ref]}") }
-      payload[:warnings].each { |w| @stderr.puts("chi models: #{w}") }
+      payload[:warnings].each do |w|
+        kept = down_hosts.any? { |host| w.start_with?("#{host}: ") }
+        @stderr.puts("chi models: #{w}#{" (its declared ids are still listed)" if kept}")
+      end
     end
   end
 end

data/lib/samagotchi/process_group.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "open3"
+
 module Samagotchi
   # A command run in a process group of its own, so a stop reaches what it
   # started too: TERM the group, a grace, then KILL it. Execute, TaskRuntime
@@ -51,12 +53,44 @@ module Samagotchi
 
     # Whether +pid+ runs and leads its own group, as #spawn's process does
     # (not, then, a reused pid in some other group).
-    def leader?(pid)
-      signalable?(pid) && Process.getpgid(pid) == pid
+    # @param started [String, nil] the start time #start_time read when chi
+    #   spawned it: a process that started at another time is one that
+    #   reused the pid, even as a group leader. nil checks the group only (a
+    #   record from an older chi), and so does a time that can't be read
+    #   now (a ps that failed once must not disown a live task).
+    # @param start_time [#call] (pid) the reader, #start_time by default
+    def leader?(pid, started: nil, start_time: method(:start_time))
+      return false unless signalable?(pid) && Process.getpgid(pid) == pid
+      return true if started.nil?
+
+      now = start_time.call(pid)
+      now.nil? || now == started
     rescue Errno::ESRCH, Errno::EPERM
       false
     end
 
+    # When +pid+'s process started, as an opaque string to compare: the
+    # start in clock ticks from /proc/PID/stat on Linux, ps's lstart (to the
+    # second, in UTC) elsewhere. nil when it isn't running or can't be read.
+    # @return [String, nil]
+    def start_time(pid)
+      return nil unless signalable?(pid)
+
+      stat = "/proc/#{pid}/stat"
+      return proc_start_time(File.read(stat)) if File.exist?(stat)
+
+      out, status = Open3.capture2({ "LC_ALL" => "C", "TZ" => "UTC" }, "ps", "-o", "lstart=", "-p", pid.to_s,
+                                   err: File::NULL)
+      time = out.strip
+      status.success? && !time.empty? ? time : nil
+    rescue SystemCallError, IOError
+      nil
+    end
+
+    # Field 22 (starttime); the command name (field 2) may hold spaces and
+    # parentheses, so the fields are counted after its last ")".
+    def proc_start_time(stat) = stat[/\A.*\)\s(.*)\z/m, 1]&.split&.[](19)
+
     # Whether +pid+ is still running (or a zombie not reaped yet).
     # @raise [ArgumentError] unless #signalable?
     def alive?(pid)
@@ -69,26 +103,39 @@ module Samagotchi
       true
     end
 
-    # TERMs the group, waits up to +grace+ for +stopped+, then KILLs it.
+    # How long #stop waits for +stopped+ after the KILL by default.
+    KILL_WAIT_SEC = 1.0
+
+    # TERMs the group, waits up to +grace+ for +stopped+, then KILLs it and
+    # waits up to +kill_wait+ for +stopped+ again (a KILL is delivered, not
+    # done, when kill returns).
     # @param stopped [#call] true once it has stopped (default: the leader
     #   is gone)
     # @param wait [#call] (seconds) between two checks (default: a sleep)
     # @param signal_options [Hash] for #signal (leader:, quiet:)
     # @return [Boolean] true when it stopped within the grace (no KILL sent)
     # @raise [ArgumentError] unless #signalable?
-    def stop(pgid, grace:, poll:, stopped: -> { !alive?(pgid) }, wait: ->(seconds) { sleep(seconds) }, **signal_options)
+    def stop(pgid, grace:, poll:, stopped: -> { !alive?(pgid) }, wait: ->(seconds) { sleep(seconds) },
+             kill_wait: KILL_WAIT_SEC, **signal_options)
       check!(pgid)
       signal(pgid, "TERM", **signal_options)
-      deadline = monotonic + grace
-      until (done = stopped.call) || monotonic >= deadline
-        wait.call(poll)
-      end
-      return true if done
+      return true if wait_for(stopped, grace, poll, wait)
 
       signal(pgid, "KILL", **signal_options)
+      wait_for(stopped, kill_wait, poll, wait)
       false
     end
 
+    # Checks +stopped+ every +poll+ until it is true or +seconds+ are over.
+    # @return [Boolean] whether it stopped
+    def wait_for(stopped, seconds, poll, wait)
+      deadline = monotonic + seconds
+      until (done = stopped.call) || monotonic >= deadline
+        wait.call(poll)
+      end
+      done ? true : false
+    end
+
     def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
     # Reads a pipe in chunks on a thread of its own, so the output read so

data/lib/samagotchi/question_desk.rb

@@ -64,6 +64,13 @@ module Samagotchi
                      "or anything else that changes files or state. Finish your reply with what you found " \
                      "and what you would do, and wait."
 
+    # The cancel reason of a question no one could answer: a
+    # --non-interactive run has no one to ask (TerminalUI).
+    UNANSWERABLE_REASON = "non_interactive"
+    UNANSWERABLE_NOTE = "No one could answer the question: this is a non-interactive run. Don't do what you " \
+                        "asked about, or anything else that changes files or state. Finish your reply with " \
+                        "what you found and what you would do."
+
     # @param session           [#call] → Session, nil
     # @param state_dir         [#call] → String, the session's state dir
     # @param emit              [#call] (event) → emits an event to the turn sink + observers
@@ -82,6 +89,8 @@ module Samagotchi
       @cv = @lock.new_cond
       @pending = nil
       @answer = nil
+      # Why the open question was cancelled (#cancel), for the sync path.
+      @cancel_reason = nil
       @sync_handler = nil
       # The standing question while it is @pending: {id:, fields:,
       # on_answer:, on_superseded_close:}; @shelved, one superseded by (or
@@ -106,7 +115,10 @@ module Samagotchi
                                     .merge(multi_select: !!payload[:multi_select], allow_freeform: !!payload[:allow_freeform]))
       # Dismissed (the card's dismiss, Esc): an answer of its own, not a
       # tool failure the model learns to avoid the tool from.
-      result = { dismissed: true, id: result[:id], note: DISMISSED_NOTE } if result.is_a?(Hash) && result[:error] == "no answer"
+      if result.is_a?(Hash) && result[:error] == "no answer"
+        note = result[:reason] == UNANSWERABLE_REASON ? UNANSWERABLE_NOTE : DISMISSED_NOTE
+        result = { dismissed: true, id: result[:id], note: note }
+      end
       # Who answered is for the relay, not the model's tool result.
       result = result.except(:by) if result.is_a?(Hash)
       result.is_a?(String) ? result : JSON.generate(result)
@@ -213,7 +225,15 @@ module Samagotchi
             emit({ type: :question_answered, id: id, answer: ans })
             return ans
           end
-          return sync_res if sync_res.is_a?(String) && !sync_res.strip.empty?
+          if sync_res.is_a?(String) && !sync_res.strip.empty?
+            # The handler's text is the answer: nothing stays pending, and
+            # every UI hears it was answered (the text as its freeform).
+            @lock.synchronize { @pending = nil }
+            clear_saved_question
+            emit({ type: :question_answered, id: id,
+                   answer: { id: id.to_s, selected: [], freeform: sync_res.strip, selected_indices: [] } })
+            return sync_res
+          end
         rescue StandardError => e
           Log.warn(:turn, "question_handler_failed", echo: "[ask_user_question] sync handler failed: #{e.message}", error: e.class.name)
         end
@@ -221,9 +241,12 @@ module Samagotchi
         # CV (no cross-thread answerer exists for synchronous UIs). Clear pending
         # and return an error so the model can fallback to plain text. Generic
         # observers will discard the stale question_requested via staleness check.
-        @lock.synchronize { @pending = nil }
+        reason = @lock.synchronize do
+          @pending = nil
+          @cancel_reason
+        end
         clear_saved_question
-        return { error: "no answer", detail: "handler failed to capture selection", id: id }
+        return { error: "no answer", detail: "handler failed to capture selection", id: id, reason: reason }.compact
       end
 
       # Block until answered/cancelled (cross-thread path: WEB/Bridge/background worker)
@@ -356,6 +379,7 @@ module Samagotchi
         next if @standing
 
         pending[:status] = "cancelled"
+        @cancel_reason = reason.to_s
         @cv.broadcast
         pending[:id]
       end
@@ -403,6 +427,7 @@ module Samagotchi
       @lock.synchronize do
         @pending = pending
         @answer = nil
+        @cancel_reason = nil
         @standing = standing&.merge(id: pending[:id])
       end
       if session

data/lib/samagotchi/recap_setup.rb

@@ -49,7 +49,7 @@ module Samagotchi
                elsif !IdleTarget.host_named?(**settings)
                  # A model naming no host goes where a bare --model goes
                  # (HostRegistry#host_for_model: the default host unless
-                 # another's list has it), resolved at each attempt.
+                 # another lists or declares it), resolved at each attempt.
                  -> { IdleTarget.resolve(**settings) }
                else
                  fixed = fixed_target(settings)

data/lib/samagotchi/self_report.rb

@@ -294,7 +294,8 @@ module Samagotchi
       served = ServedModel.from_props(props)
       return "unknown (no answer from the server's /props)" unless served
 
-      ServedModel.differs?(bare, served) ? "#{served} (not #{bare}: the server serves its own model)" : served
+      expected = entry.models&.dig(bare.to_s.downcase)&.serves?(served)
+      ServedModel.differs?(bare, served) && !expected ? "#{served} (not #{bare}: the server serves its own model)" : served
     rescue StandardError => e
       "unknown (#{e.class})"
     end

data/lib/samagotchi/served_model.rb

@@ -17,6 +17,15 @@ module Samagotchi
       name.is_a?(String) && !name.strip.empty? ? name : nil
     end
 
+    # The host whose hosts.<name>.models.<id>.served names +served+ for
+    # +target+'s model (a gateway's round-robin targets): not a mismatch to
+    # warn about. nil when none does.
+    # @param target [HostRegistry::ModelTarget]
+    # @return [String, nil]
+    def expected_by(target, served)
+      target.entry.name if target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.serves?(served)
+    end
+
     # The separators a provider uses when it decorates a model name: a tag
     # (`qwen3:latest`), a date or quant suffix (`gpt-4o-2024-08-06`), an
     # owner (`@org/name`) or a path (`meta-llama/Llama-3`). Anything else