samagotchi 0.45.0 → 0.46.0

data/lib/samagotchi/model_catalog.rb

@@ -7,33 +7,37 @@ 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: 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).
+    Row = Data.define(:host, :id, :ref, :configured) do
+      def initialize(host:, id:, ref:, configured: false) = super
+    end
+    # rows: the default host's first, then the others by name, each host's
+    # declared ids first (HostModel.rows); 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]}"
+        if results[host][:error]
+          warnings << "#{host}: #{results[host][:error]}"
           next
         end
-        Array(data[:models]).each do |info|
-          id = info.id.to_s
-          next if id.strip.empty? || id.end_with?(":batch")
+        host_rows[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)
         end
       end
       Listing.new(rows: rows, warnings: warnings)
@@ -58,6 +62,7 @@ module Samagotchi
       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
         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)

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/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/session_commands.rb

@@ -492,10 +492,11 @@ module Samagotchi
       end
     end
 
-    # "; served: <name>" when the server serves another model than asked.
+    # "; served: <name>" when the server serves another model than asked
+    # and its host's served: doesn't expect it.
     def served_note
       served, asked = @engine.served_model
-      ServedModel.differs?(asked, served) ? "; served: #{served}" : ""
+      ServedModel.differs?(asked, served) && !@engine.served_expected?(served) ? "; served: #{served}" : ""
     rescue StandardError
       ""
     end
@@ -567,6 +568,7 @@ module Samagotchi
 
       seen = Set.new
       lines = []
+      host_rows = HostModel.rows(results, registry.entries)
       # Sort hosts for deterministic output
       results.keys.sort.each do |hname|
         data = results[hname]
@@ -575,29 +577,35 @@ module Samagotchi
           lines << "#{host_label} — unreachable: #{data[:error]}"
           next
         end
-        models = Array(data[:models])
-        if models.empty?
+        # Declared ids (hosts.<name>.models) first, as "(config)", never cut
+        # by MODELS_PER_HOST.
+        rows = host_rows[hname]
+        if rows.empty?
           lines << "#{host_label} — no models discovered"
           next
         end
+        declared = []
         shown = []
-        batch_variants = batch_variant_ids(models, needle)
-        models.each do |entry|
-          identifier = entry.id.to_s.empty? ? "unknown" : entry.id
+        batch_variants = batch_variant_ids(rows, needle)
+        rows.each do |row|
+          identifier = row.id.to_s.empty? ? "unknown" : row.id
           seen << identifier.to_s.downcase
           # also track host-qualified seen for orphan logic
           seen << "#{hname}:#{identifier}".downcase
-          next if batch_variants.include?(identifier)
+          next if !row.configured && batch_variants.include?(identifier)
+          next unless needle.empty? || identifier.to_s.downcase.include?(needle)
 
-          shown << [entry, identifier] if needle.empty? || identifier.to_s.downcase.include?(needle)
+          (row.configured ? declared : shown) << [row, identifier]
         end
-        next if shown.empty?
+        next if declared.empty? && shown.empty?
 
         lines << "#{host_label}:"
         hidden = needle.empty? ? [shown.size - MODELS_PER_HOST, 0].max : 0
-        shown.first(shown.size - hidden).each do |entry, identifier|
-          raw_status = entry.raw["status"] || entry.raw[:status]
+        (declared + shown.first(shown.size - hidden)).each do |row, identifier|
+          raw = row.info&.raw || {}
+          raw_status = raw["status"] || raw[:status]
           status = raw_status.is_a?(Hash) ? (raw_status["value"] || raw_status[:value] || raw_status["status"] || raw_status[:status]) : raw_status
+          status = ["config", status].reject { |s| s.to_s.empty? }.join(", ") if row.configured
           base = status.to_s.empty? ? "  #{identifier}" : "  #{identifier} (#{status})"
           alias_list = (by_model[identifier.to_s.downcase] || []) + (by_model["#{hname}:#{identifier}".downcase] || [])
           alias_list.uniq!
@@ -631,9 +639,10 @@ module Samagotchi
     def batch_variant_ids(models, needle)
       return Set.new if needle.include?("batch")
 
+      # Any case: a declared id keeps its own spelling (HostModel.rows).
       ids = models.map { |entry| entry.id.to_s }
-      plain = ids.to_set
-      ids.select { |id| id.end_with?(":batch") && plain.include?(id.delete_suffix(":batch")) }.to_set
+      plain = ids.to_set(&:downcase)
+      ids.select { |id| id.downcase.end_with?(":batch") && plain.include?(id.downcase.delete_suffix(":batch")) }.to_set
     end
   end
 end

data/lib/samagotchi/session_metrics.rb

@@ -7,6 +7,7 @@ require "fileutils"
 require "securerandom"
 require_relative "atomic_file"
 require_relative "token_usage"
+require_relative "model_price"
 require_relative "session"
 
 module Samagotchi
@@ -58,9 +59,11 @@ module Samagotchi
     # memory_index: the memory indexes the session's prompt held
     # ({ system: { tokens:, lines: }, project: … }, string keys as saved),
     # nil when an older file has none.
+    # cost_estimate_sum: the estimated cost (hosts.<name>.models prices), 0
+    # in an older file.
     SavedSummary = Data.define(:ctx_pct, :prompt_sum, :completion_sum, :cached_sum, :reasoning_sum, :cost_sum,
-                               :memory_index) do
-      def initialize(memory_index: nil, **) = super
+                               :cost_estimate_sum, :memory_index) do
+      def initialize(memory_index: nil, cost_estimate_sum: 0, **) = super
 
       def tokens = to_h.except(:ctx_pct, :memory_index)
     end
@@ -94,15 +97,21 @@ module Samagotchi
       :gen_cache_write_max,
       :gen_reasoning_max,
       :gen_cost,
+      # The generation's configured price (ModelPrice, from
+      # :generation_started), what a generation without a reported cost
+      # (or a reported 0) is estimated from.
+      :gen_price,
       :gen_decode_tps,
       :gen_prefill_tps,
       :gen_decode_ms,
       :gen_first_chunk_at,
       # The turn's generations, folded as each one ends: the count, the last
       # one's prompt and completion, the sums, and which kinds of counts
-      # (server / estimate) they came from.
+      # (server / estimate) they came from; prompt_max is the largest
+      # prompt (an LLM context edit can make a later one smaller).
       :generations,
       :prompt_last,
+      :prompt_max,
       :prompt_sum,
       :completion_last,
       :completion_sum,
@@ -118,6 +127,8 @@ module Samagotchi
       :reprefill_sum,
       :reasoning_sum,
       :cost_sum,
+      # The estimated cost of the generations priced from config (0 when none).
+      :cost_estimate_sum,
       :decode_ms_sum,
       :decode_tokens_sum,
       :last_decode_tps,
@@ -166,6 +177,7 @@ module Samagotchi
       SavedSummary.new(ctx_pct: saved_pct(data["context"], budget_tokens), prompt_sum: count.call("prompt_sum"),
                        completion_sum: count.call("completion_sum"), cached_sum: count.call("cached_sum"),
                        reasoning_sum: count.call("reasoning_sum"), cost_sum: count.call("cost_sum"),
+                       cost_estimate_sum: count.call("cost_estimate_sum"),
                        memory_index: data["memory_index"].is_a?(Hash) ? data["memory_index"] : nil)
     rescue JSON::ParserError, SystemCallError, TypeError
       nil
@@ -322,6 +334,7 @@ module Samagotchi
             @turn.gen_started_at = monotonic_time
             @turn.generations += 1
             reset_generation_tokens
+            @turn.gen_price = generation_price(event[:price])
             @turn.gen_open = true
           end
         end
@@ -457,6 +470,7 @@ module Samagotchi
         reprefill_sum: add.call(:reprefill_sum),
         reasoning_sum: add.call(:reasoning_sum),
         cost_sum: add.call(:cost_sum),
+        cost_estimate_sum: add.call(:cost_estimate_sum),
         decode_ms_sum: decode_ms.round,
         decode_tokens_sum: decode_tokens,
         avg_decode_tps: decode_ms.positive? ? (decode_tokens * 1000.0 / decode_ms).round(1) : nil,
@@ -508,6 +522,7 @@ module Samagotchi
           gen_reasoning_max: 0,
           generations: 0,
           prompt_last: nil,
+          prompt_max: nil,
           prompt_sum: 0,
           completion_last: 0,
           completion_sum: 0,
@@ -517,6 +532,7 @@ module Samagotchi
           reprefill_sum: 0,
           reasoning_sum: 0,
           cost_sum: nil,
+          cost_estimate_sum: 0,
           decode_ms_sum: 0,
           decode_tokens_sum: 0,
           retries: 0,
@@ -627,6 +643,7 @@ module Samagotchi
       if turn.gen_had_server
         completion = turn.gen_completion_max
         turn.prompt_last = turn.gen_prompt_max
+        turn.prompt_max = [turn.prompt_max.to_i, turn.gen_prompt_max].max
         turn.prompt_sum += turn.gen_prompt_max
         turn.token_sources |= ["server"]
         speed = close_server_report(turn, completion)
@@ -656,6 +673,12 @@ module Samagotchi
       turn.cache_write_sum += turn.gen_cache_write_max
       turn.reasoning_sum += turn.gen_reasoning_max
       turn.cost_sum = turn.cost_sum.to_f + turn.gen_cost if turn.gen_cost
+      # A reported cost wins; a reported 0 with a price is taken as no report
+      # (a gateway that doesn't bill per call); the 0 stays in cost.
+      if turn.gen_price && (turn.gen_cost.nil? || turn.gen_cost.zero?)
+        turn.cost_estimate_sum += turn.gen_price.cost(prompt_tokens: turn.gen_prompt_max, cached_tokens: turn.gen_cached_max,
+                                                      cache_write_tokens: turn.gen_cache_write_max, completion_tokens: completion)
+      end
       turn.last_prefill_tps = turn.gen_prefill_tps.round(1) if turn.gen_prefill_tps
       speed = generation_speed(turn, completion)
       return unless speed
@@ -685,7 +708,9 @@ module Samagotchi
       [tps, decode_ms, source]
     end
 
-    # Caller holds the mutex.
+    # The open generation's counts start over (a new generation, or a retry
+    # that streams from the start). Its price stays: generation_started sets
+    # it, and a retry sends none. Caller holds the mutex.
     def reset_generation_tokens
       @turn.gen_completion_max = 0
       @turn.gen_prompt_max = 0
@@ -708,6 +733,7 @@ module Samagotchi
         model: turn.model,
         generations: turn.generations,
         prompt_tokens: turn.prompt_last,
+        prompt_tokens_max: turn.prompt_max,
         prompt_tokens_sum: turn.prompt_sum,
         completion_tokens: turn.completion_sum,
         context_used_tokens: turn.prompt_last && (turn.prompt_last + turn.completion_last),
@@ -738,6 +764,7 @@ module Samagotchi
       fields[:cache_write_tokens_sum] = turn.cache_write_sum if turn.cache_write_sum.positive?
       fields[:reprefill_tokens_sum] = turn.reprefill_sum if turn.reprefill_sum.positive?
       fields.merge!(cost: turn.cost_sum, cost_source: "reported") if turn.cost_sum
+      fields[:cost_estimate] = turn.cost_estimate_sum if turn.cost_estimate_sum.positive?
       fields
     end
 
@@ -862,6 +889,13 @@ module Samagotchi
       event_content.is_a?(String) ? event_content : ""
     end
 
+    # The :generation_started event's price (ModelPrice#to_h), nil for none.
+    def generation_price(hash)
+      hash.is_a?(Hash) ? ModelPrice.new(**hash.transform_keys(&:to_sym)) : nil
+    rescue ArgumentError
+      nil
+    end
+
     def monotonic_time
       @clock.call
     end
@@ -981,7 +1015,7 @@ module Samagotchi
       @totals = { cancellations: 0, prompt_sum: 0, completion_sum: 0, token_sources: [], iterations: 0,
                   gen_ms: 0, retries: 0, cuts: 0, capped: 0, by_tool: {}, tool_errors: 0, cached_sum: 0, cache_write_sum: 0,
                   reprefill_sum: 0, reasoning_sum: 0,
-                  cost_sum: 0, decode_ms_sum: 0, decode_tokens_sum: 0, last_decode_tps: nil,
+                  cost_sum: 0, cost_estimate_sum: 0, decode_ms_sum: 0, decode_tokens_sum: 0, last_decode_tps: nil,
                   last_prefill_tps: nil, tps_source: nil }
     end
 
@@ -1000,6 +1034,7 @@ module Samagotchi
       totals[:reprefill_sum] += number(record[:reprefill_tokens_sum])
       totals[:reasoning_sum] += number(record[:reasoning_tokens])
       totals[:cost_sum] += number(record[:cost])
+      totals[:cost_estimate_sum] += number(record[:cost_estimate])
       totals[:decode_ms_sum] += number(record[:decode_ms])
       totals[:decode_tokens_sum] += number(record[:decode_tokens])
       # The newest speeds a record has (an older record has none).

data/lib/samagotchi/terminal_ui/attached_view.rb

@@ -93,6 +93,8 @@ module Samagotchi
       def generation_feedback_retrying(event)
         @lock.synchronize do
           @retry = format_generation_retry_line(event)
+          # A dropped stream's step asked again: its sentence so far is void.
+          @line.reset if event[:restarted]
           # The retry streams from the start: wait for its first token again.
           @waiting_since = @clock.call if @thinking
           redraw_status

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -103,6 +103,9 @@ module Samagotchi
         return "retrying (attempt #{event[:attempt]})" unless event[:max_retries]
 
         text = "retrying (#{event[:attempt]}/#{event[:max_retries]} in #{format("%.1f", event[:next_delay].to_f)}s)"
+        # restarted: a dropped stream's step asked again (the chat loop's).
+        return "#{text}: stream dropped" if event[:restarted]
+
         event[:error_class].to_s.empty? ? text : "#{text}: #{event[:error_class]}"
       end
 
@@ -342,13 +345,25 @@ module Samagotchi
           "(#{scopes.map { |scope, tokens| "#{scope} #{count.call(tokens)}" }.join(", ")})"
       end
 
-      # "$0.42"; a cost under a cent keeps four decimals ("$0.0012"); "" for
-      # none. As ctx.js costText.
-      def cost_text(cost)
+      # "$0.42"; a cost under a cent keeps four decimals ("$0.0012"); "~$0.12"
+      # for an estimate (hosts.<name>.models prices); "" for none. As ctx.js
+      # costText.
+      def cost_text(cost, estimate: false)
         value = cost.to_f
         return "" unless value.positive?
 
-        value >= 0.01 ? format("$%.2f", value) : format("$%.4f", value)
+        "#{"~" if estimate}#{value >= 0.01 ? format("$%.2f", value) : format("$%.4f", value)}"
+      end
+
+      # /stats' cost: the reported part and the estimated one, each when present.
+      def stats_cost_text(tokens)
+        reported = cost_text(tokens[:cost_sum])
+        estimated = cost_text(tokens[:cost_estimate_sum], estimate: true)
+        return nil if reported.empty? && estimated.empty?
+        return "#{reported} (this session only)" if estimated.empty?
+
+        estimate = "#{estimated} from hosts.<name>.models prices"
+        "#{reported.empty? ? estimate : "#{reported} reported + #{estimate}"} (this session only)"
       end
 
       private
@@ -411,9 +426,9 @@ module Samagotchi
 
       # +served+ / +served_for+: the model the server said it served for the
       # name asked (see Engine#served_model); shown first when it's another
-      # model.
-      def status_model_text(model, default_model, served: nil, served_for: nil)
-        if ServedModel.differs?(served_for, served)
+      # model, unless +expected+ (the host's served: names it).
+      def status_model_text(model, default_model, served: nil, served_for: nil, expected: false)
+        if !expected && ServedModel.differs?(served_for, served)
           asked = model.to_s.length > STATUS_ASKED_MAX ? "#{model.to_s[0, STATUS_ASKED_MAX - 1]}…" : model
           return "model=#{served} (served; asked #{asked})"
         end
@@ -477,7 +492,8 @@ module Samagotchi
                  "#{token_breakdown_text(tokens)}"
         speed = stats_speed_text(tokens)
         lines << "speed:            #{speed}" if speed
-        lines << "cost:             #{cost_text(tokens[:cost_sum])} (this session only)" if tokens[:cost_sum].to_f.positive?
+        cost = stats_cost_text(tokens)
+        lines << "cost:             #{cost}" if cost
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
         lines << "retries:          #{snapshot[:retries]}"
@@ -500,7 +516,8 @@ module Samagotchi
         lines << "llm context:      #{llm_context}" if llm_context
         if snapshot[:served_model]
           asked = snapshot[:served_model_for]
-          note = ServedModel.differs?(asked, snapshot[:served_model]) ? " (asked for #{asked})" : ""
+          differs = !snapshot[:served_expected_by] && ServedModel.differs?(asked, snapshot[:served_model])
+          note = differs ? " (asked for #{asked})" : ""
           lines << "served model:     #{snapshot[:served_model]}#{note}"
         end
         lines.join("\n")

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -17,8 +17,9 @@ module Samagotchi
       # What the row shows:
       #   model, default_model  the model in use, and the config's default
       #                         (named beside another model)
-      #   served                [served, asked]: what the server said it
-      #                         served for the name asked (ServedModel)
+      #   served                [served, asked, expected]: what the server said it
+      #                         served for the name asked (ServedModel), and
+      #                         the host whose served: expects it (or nil)
       #   parent_id             the session that delegated this one
       #   children              its delegates' ChildrenStatus::Counts, or
       #                         nil (the segment shows running and waiting)
@@ -61,7 +62,7 @@ module Samagotchi
       # @param default_model [String, nil] the config's default, named beside
       #   another model
       def take_state(state, default_model: nil)
-        fields = { served: state[:served_model] ? [state[:served_model], state[:served_model_for]] : nil }
+        fields = { served: state[:served_model] ? [state[:served_model], state[:served_model_for], state[:served_expected_by]] : nil }
         fields.merge!(model: state[:model_name], default_model: default_model) if state[:model_name]
         STATE_LISTS.each { |field, key| fields[field] = Array(state[key]) if state.key?(key) }
         fields[:parent_id] = state[:parent_id] if state.key?(:parent_id)
@@ -82,7 +83,7 @@ module Samagotchi
         when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
         when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
         when :generation_completed
-          update(served: [event[:served_model], event[:requested_model]]) if event[:served_model]
+          update(served: [event[:served_model], event[:requested_model], event[:served_expected_by]]) if event[:served_model]
         end
       end
 
@@ -104,10 +105,15 @@ module Samagotchi
 
       # @return [Array<String>] the row cut to +width+ (none with nothing to say)
       def rows(width)
-        served, served_for = @values[:served]
+        served, served_for, expected = @values[:served]
         model = @values[:model]
         parent = @values[:parent_id]
-        segments = [model ? status_model_text(model, @values[:default_model], served: served, served_for: served_for) : "",
+        model_text = ""
+        if model
+          model_text = status_model_text(model, @values[:default_model], served: served, served_for: served_for,
+                                                                         expected: expected.is_a?(String))
+        end
+        segments = [model_text,
                     parent ? "↳ #{parent.to_s[0, 8]}" : "",
                     children_text(@values[:children]),
                     status_context_text(estimate: @values[:context]),

data/lib/samagotchi/terminal_ui.rb

@@ -1322,6 +1322,8 @@ module Samagotchi
 
       # The activity row goes while the question waits.
       @view.finish_thinking_spinner
+      return dismiss_unaskable_question(prompt) if @non_interactive
+
       # An edit's diff goes above the slot, into the scrollback.
       preview = prompt.preview_lines(paint: method(:paint))
       @surface.commit(preview.join("\n")) unless preview.empty?
@@ -1345,6 +1347,17 @@ module Samagotchi
       @surface.clear_slot(:notes)
     end
 
+    # --non-interactive has no one to ask (as for an approval or a hook's
+    # question there): the question is dismissed at once, as an empty answer
+    # would be, and the model finishes its reply. Never a read of stdin: a
+    # pipe its writer keeps open would block it forever. Its one line goes to
+    # stderr (#banner): stdout is the answer's alone.
+    def dismiss_unaskable_question(prompt)
+      @engine.cancel_question("user") rescue nil
+      banner(prompt.summary("(dismissed: no one to answer in a non-interactive run)", paint: method(:paint)))
+      false
+    end
+
     # Loop until a valid selection or a cancel. The block reads one answer:
     # a line, nil (Ctrl-D, or Ctrl-C with no turn), or :canceled (the turn
     # was cancelled).