samagotchi 0.44.0 → 0.45.0

data/lib/samagotchi/host_registry.rb

@@ -235,6 +235,26 @@ module Samagotchi
       end
     end
 
+    # List one host's models and save them to ModelListStore: what
+    # ModelProfile.model_warning re-lists on a miss (a fresh saved list that
+    # lacks the id: the server may have been reloaded with another model),
+    # so the saved list catches up at spawn time. Only that host is asked,
+    # and never through the cache (a fresh listing is the point).
+    # @param name [String, Symbol, nil] a host name; anything else lists
+    #   nothing
+    # @return [Array<String>, nil] the ids the host lists now, nil for an
+    #   unknown name or when the host fails to list (nothing is saved then:
+    #   a host that is down keeps the ids we know)
+    def list_models(name)
+      entry = name.nil? ? nil : find_entry(name)
+      return nil unless entry
+
+      save_model_list(entry.name, list_models_for(entry))&.ids
+    rescue StandardError => e
+      Log.warn(:model, "list_failed", host: name.to_s, error: e.class.name, msg: e.message.to_s[0, 500])
+      nil
+    end
+
     def client_for_model(raw_model)
       host_entry, bare = host_for_model(raw_model)
       [client_for(host_entry), bare, host_entry]
@@ -293,9 +313,7 @@ module Samagotchi
             models = list_models_for(entry)
             data = { host: entry.host, port: entry.port, transport: entry.transport, models: models, error: nil }
             @mutex.synchronize { @host_lists[name] = { data: data, at: @clock.call } }
-            # On disk too: a process that spawns a worker without listing
-            # (`chi send --new --model`, delegate) checks an id against it.
-            ModelListStore.save(name, models.map(&:id))
+            save_model_list(name, models)
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
             data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: e.message }
@@ -350,6 +368,13 @@ module Samagotchi
 
     private
 
+    # Save a host's just-listed models on disk, for the processes that spawn
+    # a worker without listing (`chi send --new --model`, delegate):
+    # ModelListStore is what they check an id against.
+    def save_model_list(name, models)
+      ModelListStore.save(name, Array(models).map(&:id))
+    end
+
     def fresh_list(name, entry)
       @mutex.synchronize do
         cached = @host_lists[name]

data/lib/samagotchi/llm_context_strategy.rb

@@ -167,6 +167,43 @@ module Samagotchi
                     budget_tokens: budget_origin)
     end
 
+    # A session's LLM context strategy, apply rule and budget, each with
+    # where it came from (Explained#summary), as its worker would resolve
+    # them; nil when they can't be (an unreadable config, a model that
+    # resolves nowhere). Resolves from config and the registry only: no
+    # network, no model call. What a session page, a session list's ctx %
+    # and a spawn-time check all read.
+    # @param session [Session, nil]
+    # @param registry [HostRegistry, nil] the hosts to resolve against;
+    #   HostRegistry.new by default (what the caller usually has)
+    # @return [Hash, nil] Explained#summary, symbol keys
+    def for_session(session, registry: nil)
+      return nil if session.nil?
+
+      require_relative "config"
+      registry ||= begin
+        require_relative "host_registry"
+        HostRegistry.new
+      end
+      name = session.model_name.to_s.strip.empty? ? ModelProfile.required_model_name(nil) : session.model_name
+      target = registry.resolve(name)
+      names = registry.lookup_names(session.model_typed || name, resolved: name, target: target)
+      own = session.llm_context
+      explain(target, names: names, **(own&.resolve_args || {})).summary(own)
+    rescue StandardError
+      nil
+    end
+
+    # The budget a session's turns run under (for_session's :budget_tokens),
+    # nil when it is off or can't be resolved. What a session list's ctx %
+    # counts against, so a saved session's fill reads as the live meter.
+    # @param session [Session, nil]
+    # @param registry [HostRegistry, nil] see .for_session
+    # @return [Integer, nil]
+    def session_budget(session, registry: nil)
+      for_session(session, registry: registry)&.fetch(:budget_tokens, nil)
+    end
+
     # [the budget, its Origin]: the session's own first (0 there is off,
     # whatever the model says).
     def budget_for(target, names, models, session_budget)

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_profile.rb

@@ -187,7 +187,6 @@ 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
@@ -195,11 +194,24 @@ module Samagotchi
     # 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)
@@ -210,10 +222,67 @@ module Samagotchi
 
       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/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)

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("; ")})"

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.

data/lib/samagotchi/session_metrics.rb

@@ -141,22 +141,29 @@ module Samagotchi
     # its saved analytics.json: a percentage, or nil when the file, the count
     # or the window is missing (the session lists read it per row).
     # @param session_dir [String]
+    # @param budget_tokens [Integer, Proc, nil] the session's LLM context
+    #   budget; a positive one smaller than the window is what the fill is
+    #   counted against (the live meter counts the same way,
+    #   ContextStatus#counted_against). nil or 0: the window. A callable is
+    #   resolved only when there is a context to count, so a caller can build
+    #   a registry lazily.
     # @return [Float, nil]
-    def self.saved_context_pct(session_dir)
-      saved_summary(session_dir)&.ctx_pct
+    def self.saved_context_pct(session_dir, budget_tokens: nil)
+      saved_summary(session_dir, budget_tokens: budget_tokens)&.ctx_pct
     end
 
     # The context's fill and the token totals from the session's saved
     # analytics.json, read once; nil without a readable file.
     # @param session_dir [String]
+    # @param budget_tokens [Integer, Proc, nil] see .saved_context_pct
     # @return [SavedSummary, nil]
-    def self.saved_summary(session_dir)
+    def self.saved_summary(session_dir, budget_tokens: nil)
       data = JSON.parse(File.read(File.join(session_dir, "analytics.json")))
       return nil unless data.is_a?(Hash)
 
       tokens = data["tokens"].is_a?(Hash) ? data["tokens"] : {}
       count = ->(key) { tokens[key].is_a?(Numeric) ? tokens[key] : 0 }
-      SavedSummary.new(ctx_pct: saved_pct(data["context"]), prompt_sum: count.call("prompt_sum"),
+      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"),
                        memory_index: data["memory_index"].is_a?(Hash) ? data["memory_index"] : nil)
@@ -164,15 +171,25 @@ module Samagotchi
       nil
     end
 
-    def self.saved_pct(context)
+    def self.saved_pct(context, budget_tokens)
       return nil unless context.is_a?(Hash)
 
       used = context["used_tokens"]
       window = context["window_tokens"]
       return nil unless used.is_a?(Numeric) && window.is_a?(Numeric) && window.positive?
 
-      used * 100.0 / window
+      used * 100.0 / counted_against(budget_tokens, window)
     end
+
+    # What the saved fill counts against: the window, or the budget when one
+    # is set and smaller (ContextStatus#counted_against, the live meter's
+    # rule). The budget is resolved here, not by the caller, so a caller
+    # that builds one lazily doesn't build it for a row with no context.
+    def self.counted_against(budget_tokens, window_tokens)
+      budget = budget_tokens.respond_to?(:call) ? budget_tokens.call : budget_tokens
+      budget.is_a?(Numeric) && budget.positive? ? [budget, window_tokens].min : window_tokens
+    end
+    private_class_method :counted_against
     private_class_method :saved_pct
 
     # One turn's tool records from the session's saved analytics.json, in
@@ -192,6 +209,22 @@ module Samagotchi
       []
     end
 
+    # One turn's saved record from the session's analytics.json, string-keyed
+    # as saved: what a join replays the turn's failure (or cancel) line from.
+    # nil without a turn id (an older session's prompt), the file, records,
+    # or a record for the turn.
+    # @param session_dir [String]
+    # @param turn_id [String, nil]
+    # @return [Hash, nil]
+    def self.saved_turn_record(session_dir, turn_id)
+      return nil if turn_id.to_s.empty?
+
+      records = JSON.parse(File.read(File.join(session_dir, "analytics.json")))["turn_records"]
+      Array(records).find { |r| r.is_a?(Hash) && r["id"] == turn_id }
+    rescue JSON::ParserError, SystemCallError, TypeError
+      nil
+    end
+
     # "ctx 12%" for the session lists, "" when unknown.
     # @param pct [Float, nil]
     # @return [String]

data/lib/samagotchi/sessions_command.rb

@@ -226,14 +226,24 @@ module Samagotchi
         recap = Samagotchi::RecapStore.preview(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
         (recap || Samagotchi::SessionManager.summary_text(s))[0, 60]
       end
+      # How full the context was after the last turn: "ctx 12%", counted
+      # against the session's llm_context budget when one is set and smaller
+      # than the window, as the live meter counts it (one registry for the
+      # whole table, built when the first row has a saved context). Blank when
+      # unknown.
+      budgets = nil
+      ctx = lambda do |s|
+        Samagotchi::SessionMetrics.context_label(
+          Samagotchi::SessionMetrics.saved_context_pct(
+            Samagotchi::Session.session_dir(s.id, state_dir: state_dir),
+            budget_tokens: -> { Samagotchi::LLMContextStrategy.session_budget(s, registry: budgets ||= Samagotchi::HostRegistry.new) }
+          )
+        )
+      end
       # A delegated session points at its parent: ↳ <parent's short id>.
       row = lambda do |s|
         flag = session_flag(scratch: s.scratch, test_run: s.test_run, archived: s.archived, stopped_by: s.stopped_by)
         child = s.parent_id ? "  ↳ #{s.parent_id[0, 8]}" : ""
-        # How full the context was after the last turn: "ctx 12%", blank when unknown.
-        ctx = Samagotchi::SessionMetrics.context_label(
-          Samagotchi::SessionMetrics.saved_context_pct(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
-        )
         # A question waits for an answer (chi answer, the web, chi --attach).
         live = s.pending_question && Samagotchi::SessionManager.worker_live?(s.id, state_dir: state_dir)
         waiting = s.waiting_question(live: !!live)
@@ -241,7 +251,7 @@ module Samagotchi
                  elsif waiting then "waiting"
                  else s.status
                  end
-        "#{s.id}  #{status.ljust(8)}  #{ctx.ljust(8)}  #{s.updated_at}  #{list_text.call(s)}#{flag}#{child}"
+        "#{s.id}  #{status.ljust(8)}  #{ctx.call(s).ljust(8)}  #{s.updated_at}  #{list_text.call(s)}#{flag}#{child}"
       end
       if project
         sessions.each { |s| @stdout.puts row.call(s) }