samagotchi 0.44.0 → 0.46.0

data/lib/samagotchi/model_notes.rb

@@ -63,7 +63,8 @@ module Samagotchi
         files(scope, env).filter_map do |path|
           next unless seen.add?(File.expand_path(path))
 
-          note_at(path, scope, name: name, key: key, fallback_key: fallback_key, muted: muted, small: small_once)
+          note_at(path, scope, name: name, key: key, fallback_key: fallback_key, muted: muted, small: small_once,
+                  env: env)
         end
       end
       warn_sizes(notes) if warn
@@ -110,7 +111,7 @@ module Samagotchi
       []
     end
 
-    def note_at(path, scope, name:, key:, fallback_key:, muted:, small:)
+    def note_at(path, scope, name:, key:, fallback_key:, muted:, small:, env: ENV)
       stem = File.basename(path, ".md")
       return nil if dotted?(path, stem)
       return nil if MutedMemories.muted?(stem, muted)
@@ -122,7 +123,7 @@ module Samagotchi
       body = File.read(path, encoding: "UTF-8").sub(/\A[^\n]*\n?/, "").strip
       return nil if body.empty?
 
-      body = with_overlay(body, stem, scope, [key, fallback_key])
+      body = with_overlay(body, stem, scope, [key, fallback_key], env: env)
 
       Note.new(name: stem, scope: scope, body: body, chars: body.length, digest: Digest::SHA256.hexdigest(body)[0, 12])
     rescue StandardError
@@ -131,10 +132,11 @@ module Samagotchi
 
     # The note's model overlay appended as memory_read appends one: the
     # key's, else the fallback key's. The file is read by its own path, not
-    # by name through memory_read (whose names are comma lists).
-    def with_overlay(body, stem, scope, keys)
+    # by name through memory_read (whose names are comma lists). +env+: the
+    # XDG env the scope's dir (and so the overlay) resolves from.
+    def with_overlay(body, stem, scope, keys, env: ENV)
       keys.compact.each do |overlay_key|
-        overlay = ModelOverlay.overlay_path_for(stem, overlay_key, scope)
+        overlay = ModelOverlay.overlay_path_for(stem, overlay_key, scope, env: env)
         next unless overlay && File.file?(overlay)
 
         return "#{body}#{Tools::MemoryRead::SEPARATOR}Model-specific guidance (#{overlay_key}):\n" \

data/lib/samagotchi/model_overlay.rb

@@ -38,10 +38,11 @@ module Samagotchi
 
     # Return the expected file path for an overlay in the given scope.
     # Respects MemoryBundle overrides (delegates to Tools::MemoryRead.memories_dir).
-    def self.overlay_path_for(name, key, scope)
+    # @param env [Hash] the XDG env the scope's memories dir resolves from
+    def self.overlay_path_for(name, key, scope, env: ENV)
       return nil unless key && !key.to_s.strip.empty?
 
-      File.join(Tools::MemoryRead.memories_dir(scope), "#{name}.#{key.to_s.strip}.md")
+      File.join(Tools::MemoryRead.memories_dir(scope, env: env), "#{name}.#{key.to_s.strip}.md")
     end
 
     # Regex matching overlay file names: /<something>.<lowercase-dashed-key>.md\z

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

@@ -187,19 +187,31 @@ module Samagotchi
     # named before the worker's first turn fails on it. Only a warning: some
     # hosts serve ids they don't list (a one-model llama.cpp server takes any
     # name, OpenRouter's :nitro variants), so the session starts anyway.
-    # Never asks a host.
     #
     # 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).
+    #
+    # A saved list that lacks the id may itself be stale by content: a
+    # one-model server was reloaded with another model while the list still
+    # names the old one. So a miss in a saved list older than
+    # RELIST_AFTER_SECONDS re-lists that one host once, judges again against
+    # what it lists now, and lets the saved list take the re-list's ids (the
+    # default re-list saves them too). A younger saved list, a hit, no list,
+    # a stale list (TTL_SECONDS) or a ref that names no host never asks a
+    # host; a re-list that fails, times out (RE_LIST_TIMEOUT_SECONDS) or
+    # lists nothing warns from the saved list (a host that is down is no
+    # evidence either way).
     # @param hosts [Hash, nil] the hosts a prefix may name (a HostRegistry's
     #   entries); config.yml's by default
     # @param lists [#read] ModelListStore by default
+    # @param relist [#call, nil] how a miss re-lists the host:
+    #   (host_name, env) -> ids or nil. HostRegistry#list_models by default.
     # @return [String, nil]
-    def self.model_warning(model_name, env: ENV, hosts: nil, lists: nil)
+    def self.model_warning(model_name, env: ENV, hosts: nil, lists: nil, relist: nil)
       require_relative "config"
       require_relative "model_list_store"
       hosts ||= Samagotchi::ConfigFile.hosts_config(env: env)
@@ -207,13 +219,72 @@ 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)
+      # A saved list this recent is taken at its word. Re-listing every miss
+      # would make each launch of an id a host serves but never lists (a
+      # gateway's round-robin aliases) pay the re-list's cap and warn
+      # anyway; a list that old is the case worth catching (a one-model
+      # server reloaded with another model).
+      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).
+      if fresh_ids
+        Samagotchi::ModelListStore.save(host, fresh_ids, env: env)
+        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)
+      end
 
+      # No answer (failed, timed out, listed nothing): the saved list stands.
       unknown_model_message(parsed.id, host, list.ids)
     end
 
+    # How long a miss's re-list may take before it is treated as failed: a
+    # spawn (`chi send --new --model`, delegate) warns from the saved list
+    # then, rather than wait on a slow host.
+    RE_LIST_TIMEOUT_SECONDS = 5
+
+    # A saved list younger than this is not re-listed on a miss (the other
+    # way it can be wrong: stale by CONTENT within its TTL, a one-model
+    # server reloaded with another model). A host that serves ids it never
+    # lists (a gateway's round-robin aliases) would otherwise pay the
+    # re-list's cap on every launch.
+    RELIST_AFTER_SECONDS = 10 * 60
+
+    # The default re-list: one HostRegistry, one host listed (and saved).
+    # Bounded like `chi models`' `wait:`: a thread still listing at the cap
+    # is left running and its answer ignored (only a short-lived spawn is
+    # ever here).
+    # @return [#call] (host_name, env) -> ids or nil
+    def self.default_relist(hosts)
+      lambda do |host_name, relist_env|
+        require_relative "host_registry"
+        registry = Samagotchi::HostRegistry.new(hosts_config: hosts, env: relist_env)
+        answer = nil
+        thread = Thread.new { answer = registry.list_models(host_name) }
+        thread.join(RE_LIST_TIMEOUT_SECONDS)
+        answer
+      end
+    end
+    private_class_method :default_relist
+
+    # The re-list's ids, or nil when it fails, times out or lists nothing.
+    # A failing re-list is no evidence either way: the caller warns from the
+    # saved list.
+    def self.relist_or_nil(relist, host, env)
+      ids = relist.call(host, env)
+      ids.respond_to?(:any?) && ids.any? ? ids : nil
+    rescue StandardError
+      nil
+    end
+    private_class_method :relist_or_nil
+
     # The warning for an id the host doesn't list, with up to three close
     # ids (Config.near_names) when there are any.
     def self.unknown_model_message(id, host, ids)

data/lib/samagotchi/plugin/context.rb

@@ -105,13 +105,15 @@ module Samagotchi
 
       # Whether the session is a delegate child (Session#delegate?): a task
       # another session handed over, not the user's own.
-      def delegate?
-        id = session_id
-        return false unless id
-
-        Session.load(id, state_dir: @host.state_dir&.call || Session.default_state_dir).delegate?
-      rescue ArgumentError
-        false
+      def delegate? = !!saved_session&.delegate?
+
+      # Whether the session is a fork (ctx.sessions.fork: /btw keep, a
+      # plugin's): it has a parent and isn't a delegate child, and it
+      # started from a conversation, so its first prompt isn't its first
+      # user message.
+      def fork?
+        session = saved_session
+        !session.nil? && !session.parent_id.nil? && !session.delegate?
       end
 
       # @return [String] the session's working directory
@@ -297,6 +299,16 @@ module Samagotchi
         helper.respond_to?(:call) ? helper : nil
       end
 
+      # The session's file as saved, nil without an id or a file.
+      def saved_session
+        id = session_id
+        return nil unless id
+
+        Session.load(id, state_dir: @host.state_dir&.call || Session.default_state_dir)
+      rescue ArgumentError
+        nil
+      end
+
       def deep_freeze(value)
         case value
         when Hash then value.to_h { |k, v| [deep_freeze(k), deep_freeze(v)] }.freeze

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

@@ -197,14 +197,43 @@ module Samagotchi
     # takes them at its next build (/stats names the ones it carries).
     def model_notes_for(model, env)
       bare = HostRegistry.new(env: env).bare_name(model)
-      notes = ModelNotes.for(name: bare, key: ModelOverlay.key_for(bare), muted: session_muted(env), env: env,
-                             warn: false)
+      key = ModelOverlay.key_for(bare)
+      notes = ModelNotes.for(name: bare, key: key, fallback_key: fallback_model_key(model, key, env),
+                             muted: session_muted(env), env: env, warn: false)
       text = PromptNote.text(notes.map { |note| PromptNote.from_note(note) })
       text.empty? ? "none" : text
     rescue StandardError => e
       "(unreadable: #{e.message})"
     end
 
+    # The overlay key read when the key has none (SystemPrompt::ModelIdentity
+    # #fallback_key): the key of the name the model was typed as, when the
+    # session chi self runs in has one (an alias), else of the name chi self
+    # reports. nil when that is the key itself. Read-only, never raising.
+    def fallback_model_key(model, key, env)
+      typed = session_typed_model(env) || model
+      typed_key = ModelOverlay.key_for(HostRegistry.new(env: env).parse_qualified_model(typed).last)
+      typed_key == key ? nil : typed_key
+    rescue StandardError
+      nil
+    end
+
+    # The model name the session chi self runs in was typed as (an alias),
+    # its model_typed, else nil.
+    def session_typed_model(env)
+      id = env[PARENT_SESSION_ENV].to_s
+      return nil if id.empty? || !Session.valid_id?(id)
+
+      state_dir = Session.default_state_dir(env: env)
+      return nil unless Session.exist?(id, state_dir: state_dir)
+
+      session = Session.load(id, state_dir: state_dir)
+      typed = session.model_typed.to_s.strip
+      typed.empty? ? nil : typed
+    rescue StandardError
+      nil
+    end
+
     # The --mute list of the session chi self runs in (its execute exports
     # SAMAGOTCHI_PARENT_SESSION); [] outside one.
     def session_muted(env)
@@ -265,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

@@ -39,6 +39,9 @@ module Samagotchi
     # /exit --delete: delete the session on the way out.
     EXIT_DELETE_FLAG = "--delete"
 
+    # /help's note per listed mid_turn (the web's command list says the same).
+    MID_TURN_NOTES = { "anytime" => "mid-turn too", "depends" => "show: mid-turn too" }.freeze
+
     # @!attribute status [Symbol] :ok, or :error when the line was refused
     # @!attribute output [String, nil] what to tell the user
     # @!attribute changed [Array<Symbol>] :messages and/or :model
@@ -52,21 +55,28 @@ module Samagotchi
     # Puts the built-in commands into +registry+, in lookup order (!rollback
     # before !cmd): the ones #run runs, then the UIs' own (local: Tab and
     # help only).
+    #
+    # While a turn runs, a show form (the name alone) runs at once beside
+    # it (it only reads); setting forms and !cmd run after the turn; !rollback
+    # and /continue are refused (Commands::Registry::MID_TURN).
     def self.register_builtins(registry)
       registry.register(ROLLBACK_COMMAND, "discard the interrupted turn and restore the pre-turn state",
                         id: :rollback) { |_text| rollback }
       registry.register("!", "run a shell command; its output goes into the conversation",
-                        id: :shell, match: ->(text) { text.match?(/\A!\s*\S/) }) { |text| shell(text) }
+                        id: :shell, mid_turn: :queue, match: ->(text) { text.match?(/\A!\s*\S/) }) { |text| shell(text) }
       registry.register(CONTINUE_COMMAND, "answer the continue offer (yes, no or no, <reason>)") do |text|
         next reply("nothing to continue") unless @turn_flow.awaiting_continue?
 
         answer = text.delete_prefix(CONTINUE_COMMAND).strip
         continue_answer(answer.empty? ? CONTINUE_COMMAND : answer)
       end
-      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)") do |text|
+      # It reads the hosts only (the registry is mutex-guarded): mid-turn too.
+      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)",
+                        mid_turn: ->(_text) { :anytime }) do |text|
         reply(models_listing(text.delete_prefix(MODELS_COMMAND).strip))
       end
-      registry.register(GUARDRAILS_COMMAND, "list the guardrail rules and approvals (/guardrails revoke N)") do |text|
+      registry.register(GUARDRAILS_COMMAND, "list the guardrail rules and approvals (/guardrails revoke N)",
+                        mid_turn: show_mid_turn(GUARDRAILS_COMMAND)) do |text|
         guardrails(text.delete_prefix(GUARDRAILS_COMMAND).strip)
       end
       # It only reads the store: mid-turn too.
@@ -74,11 +84,11 @@ module Samagotchi
                                                                                    match: ->(text) { text.casecmp?(CONTEXT_COMMAND) }) do |_text|
         reply(context_listing)
       end
-      registry.register(MODEL_COMMAND, "show or switch the model",
+      registry.register(MODEL_COMMAND, "show or switch the model", mid_turn: show_mid_turn(MODEL_COMMAND),
                         match: ->(text) { text.match?(%r{\A/model(?:\s+.*)?\z}) }) { |text| model(text) }
-      # Not anytime: it saves the session; it takes effect at the next turn's start.
+      # Setting it saves the session; it takes effect at the next turn's start.
       registry.register(LLM_CONTEXT_COMMAND, "show or set this session's LLM context strategy, apply rule and budget",
-                        id: :llm_context, match: ->(text) { text.match?(%r{\A/llm-context(?:\s+.*)?\z}) }) { |text| llm_context(text) }
+                        id: :llm_context, mid_turn: show_mid_turn(LLM_CONTEXT_COMMAND), match: ->(text) { text.match?(%r{\A/llm-context(?:\s+.*)?\z}) }) { |text| llm_context(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
@@ -94,6 +104,13 @@ module Samagotchi
       registry
     end
 
+    # @return [#call] line → :anytime for +name+ alone (it shows), else
+    #   :queue (it sets what the next turn runs under)
+    def self.show_mid_turn(name)
+      ->(text) { text == name ? :anytime : :queue }
+    end
+    private_class_method :show_mid_turn
+
     # @param word [String] the regexp source of the exit word
     def self.exit_match(word)
       pattern = /\A#{word}(?:\s+#{EXIT_DELETE_FLAG})?\z/i
@@ -149,7 +166,7 @@ module Samagotchi
       lines = entries.map do |entry|
         notes = []
         notes << entry.source unless entry.source == "core"
-        notes << "mid-turn too" if entry.anytime
+        notes << MID_TURN_NOTES[entry.mid_turn_label] if MID_TURN_NOTES[entry.mid_turn_label]
         notes << (entry.uis ? "#{entry.uis.join(" and ")} only" : "terminal only") if entry.local
         line = "  #{self.class.display_name(entry).ljust(width)}  #{entry.description}"
         notes.empty? ? line : "#{line}  (#{notes.join("; ")})"
@@ -475,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
@@ -550,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]
@@ -558,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!
@@ -614,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_manager.rb

@@ -12,6 +12,8 @@ require_relative "config"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "session_metrics"
+require_relative "llm_context_strategy"
+require_relative "host_registry"
 require_relative "utf8_default"
 require_relative "turn_note"
 require_relative "owner_lock"
@@ -290,6 +292,10 @@ module Samagotchi
       sd = state_dir || Session.default_state_dir
       root = cwd && folder_path(cwd)
       roots = {}
+      # One registry per listing, built only when a row has a saved context
+      # to count: its session's llm_context budget is what ctx_pct counts
+      # against (SessionMetrics.saved_context_pct).
+      budgets = listing_budgets
       summaries = Session.list(state_dir: sd, sort: sort || "updated_at", order: order || "desc", project_root: project_root,
                                include_archived: include_archived).lazy
                          .reject { |s| (!include_tests && s.test_run) || s.id == exclude }
@@ -302,7 +308,8 @@ module Samagotchi
         { id: s.id, short_id: s.id[0, 8], desc: summary_desc(s), preview: summary_preview(s), cwd: s.working_directory,
           project: s.project_root(cache: roots), updated_at: s.updated_at, status: s.status, live: owned, busy: owned && s.status == Session::STATUS_RUNNING,
           owner: owner&.kind, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
-          ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd))&.round(1),
+          ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd),
+                                                    budget_tokens: -> { budgets.call(s) })&.round(1),
           parent_id: s.parent_id, parent_short_id: s.parent_id&.[](0, 8), delegate: s.delegate?, archived: s.archived,
           scratch: s.scratch, test_run: s.test_run, stopped_by: s.stopped_by }.merge(waiting_fields(s.waiting_question(live: owned)))
       end
@@ -316,6 +323,17 @@ module Samagotchi
     end
     private_class_method :waiting_fields
 
+    # One HostRegistry for a whole listing, built on the first row that
+    # needs it (a saved context to count) and kept for the rest: resolving a
+    # session's llm_context budget reads config.yml (mtime-cached), so not
+    # one registry per row.
+    # @return [#call] (session) -> the session's budget in tokens or nil
+    def self.listing_budgets
+      registry = nil
+      ->(session) { LLMContextStrategy.session_budget(session, registry: registry ||= HostRegistry.new) }
+    end
+    private_class_method :listing_budgets
+
     # The sessions delegated by +parent_id+ (the `delegate` tool), newest
     # first, as .session_summaries rows. A running one (busy) counts against
     # session.max_children. Archived ones too.