samagotchi 0.44.0 → 0.46.0

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,
@@ -141,38 +152,56 @@ 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"),
+                       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
     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 +221,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]
@@ -289,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
@@ -424,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,
@@ -475,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,
@@ -484,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,
@@ -594,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)
@@ -623,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
@@ -652,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
@@ -675,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),
@@ -705,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
 
@@ -829,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
@@ -948,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
 
@@ -967,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/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) }

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -126,6 +126,10 @@ module Samagotchi
         @early_lines = []
         @question = nil
         @answered_ids = Set.new
+        # Commands queued for after the running turn, any UI's: a /archive
+        # typed during the turn waits for them too (#archive_due?).
+        @queued_ids = Set.new
+        @archive_after_turn = false
         @reader = nil
         @first_prompt = first_prompt
         @first_commands = Array(first_command)
@@ -188,6 +192,7 @@ module Samagotchi
           when :event
             ended = safely_handle(payload)
             return ended if %i[closed failed unanswered].include?(ended)
+            return archive_now if archive_due?
 
             ended = take_early_lines
             return ended if ended
@@ -264,9 +269,11 @@ module Samagotchi
         when :answer_display then @display_pending = false
         when :context_status, :used_memories_updated then @status.take_event(event)
         # Another client's anytime command: its line now, before the cards
-        # it shows (its command_ran comes when it's done).
+        # it shows (its command_ran comes when it's done). One queued for
+        # after the turn says so now.
         when :command_queued
           @screen.commit(prompt_line(event[:client_id], event[:line])) if event[:anytime] && !own?(event[:client_id]) && !event[:card]
+          command_waits(event) if event[:waits] && !event[:card]
         when :command_ran
           command_ran(event)
           return first_command_ran(event) if @first_command_id && event[:command_id] == @first_command_id
@@ -379,6 +386,7 @@ module Samagotchi
         local = command_registry.lookup_local(text)&.id
         return submit(nil) if local == :detach
         return SessionCommands.delete_on_exit?(text) ? exit_and_delete : exit_worker if local == :exit
+        return archive_after_turn if local == :archive && (@running || !@queued_ids.empty?)
         return exit_and_archive if local == :archive
 
         if @continue_offer
@@ -446,6 +454,24 @@ module Samagotchi
         detach("Detached; the worker is stopping, but session #{id} was not deleted (#{e.message}): chi sessions delete #{id}")
       end
 
+      # /archive during a turn (D2): it waits for the turn's end and the
+      # commands queued behind it (#archive_due?), then runs.
+      # @return [nil]
+      def archive_after_turn
+        @archive_after_turn = true
+        @screen.commit("(archives after this turn)")
+        nil
+      end
+
+      def archive_due? = @archive_after_turn && !@running && @queued_ids.empty?
+
+      # @return [Symbol] :detached
+      def archive_now
+        @archive_after_turn = false
+        exit_and_archive
+        :detached
+      end
+
       # /archive: the worker is asked to exit as for /exit, then the session
       # is archived. A worker staying up for another UI (or reminders) is
       # stopped by the archive, as the web's archive stops it; a turn
@@ -546,13 +572,36 @@ module Samagotchi
         "worker unreachable: #{head.downcase}"
       end
 
+      QUEUED_NOTE = "(queued: runs after this turn)"
+
+      # A command queued for after the running turn (command_queued with
+      # waits): its line now (another client's) and a note; its command_ran
+      # has no line again (queued: true).
+      def command_waits(event)
+        @queued_ids << event[:command_id]
+        if own?(event[:client_id])
+          first = event[:command_id] == @first_command_id
+          return @screen.commit(first ? first_command_queued : QUEUED_NOTE)
+        end
+
+        @screen.commit("#{prompt_line(event[:client_id], event[:line])} #{QUEUED_NOTE}")
+      end
+
+      def first_command_queued
+        flag = @first_command_line.to_s.start_with?("/model") ? "--model" : "--llm-context"
+        "(#{flag} queued: applies after the running turn)"
+      end
+
       def command_ran(event)
         @open_ids.delete(event[:command_id])
-        @screen.commit(prompt_line(event[:client_id], event[:line])) unless own?(event[:client_id]) || event[:anytime] || event[:card]
+        @queued_ids.delete(event[:command_id])
+        unless own?(event[:client_id]) || event[:anytime] || event[:card] || event[:queued]
+          @screen.commit(prompt_line(event[:client_id], event[:line]))
+        end
         output = event[:output].to_s
         if output.empty?
           nil
-        elsif event[:status] == "busy" || PromptHistory.shell_line?(event[:line])
+        elsif %w[busy dropped].include?(event[:status]) || PromptHistory.shell_line?(event[:line])
           @screen.commit(output)
           put_back_busy_command(event) if event[:status] == "busy"
         else
@@ -992,6 +1041,14 @@ module Samagotchi
           @shown_enqueued << entry[:enqueued_id]
           @screen.commit("queued #{prompt_line(entry[:client_id], entry[:prompt])}")
         end
+        # Commands waiting for the turn's end (their command_ran prints no
+        # line); a resync prints only the ones it hadn't shown.
+        shown = @queued_ids.dup
+        @queued_ids.clear
+        Array(snapshot[:queued_commands]).each do |entry|
+          @queued_ids << entry[:command_id]
+          @screen.commit("queued #{prompt_line(entry[:client_id], entry[:line])}") unless shown.include?(entry[:command_id])
+        end
         return send_first_command unless @first_commands.empty?
 
         send_first_prompt
@@ -1076,10 +1133,18 @@ module Samagotchi
         Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         from = messages.index { |m| m.equal?(exchange[last_user]) }
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
+        failed = join_failed_record(exchange[last_user])
         # A turn that ended with no answer: its notice, as live.
         empty = messages.drop(from + 1).filter_map { |m| TurnNote.empty_answer(m) }.last
         if empty
           @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"]))
+        elsif failed
+          # A failed turn whose steps stayed: the line the live view left,
+          # and no step text as if it were the answer (the web keeps a
+          # failed turn's texts as steps too).
+          failure = failed["failure"]
+          @screen.commit(@view.turn_failed_line(failure["summary"] || failure["message"], failed["duration_ms"]))
+          @screen.commit(@view.turn_end_hint(ROLLBACK_HINT)) if failure["kept_steps"]
         else
           # The saved answer is raw: the latest keeps its thinking, and one may
           # be only a tool call.
@@ -1119,6 +1184,23 @@ module Samagotchi
         []
       end
 
+      # The turn's saved record when it failed with the fields its line is
+      # made of (SessionMetrics#failure_fields), else nil: a completed,
+      # canceled or older turn — or one saved before the failure field —
+      # draws its answer as before.
+      def join_failed_record(prompt)
+        record = SessionMetrics.saved_turn_record(Session.session_dir(@client.session_id),
+                                                  prompt[:turn_id] || prompt["turn_id"])
+        return nil unless record && record["status"] == "failed" && record["failure"].is_a?(Hash)
+
+        failure = record["failure"]
+        return nil if failure["summary"].to_s.empty? && failure["message"].to_s.empty?
+
+        record
+      rescue Session::InvalidId
+        nil
+      end
+
       # The duration of +part+'s call: the next record of its tool, in call
       # order, consumed with the ones it skipped. By tool and order, not by
       # iteration: an empty retry spends an iteration that left no message.

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]}"
@@ -486,7 +502,7 @@ module Samagotchi
         lines << "output cap hits:  #{snapshot[:capped].to_i}"
         context = snapshot[:context] || {}
         if context[:used_tokens]
-          pct = context[:window_tokens].to_i.positive? ? format(" (%.1f%%)", context[:used_tokens] * 100.0 / context[:window_tokens]) : ""
+          pct = context_pct_text(context, snapshot[:llm_context])
           lines << "context used:     #{context[:used_tokens]} tokens#{pct}"
         end
         lines << "context window:   #{context[:window_tokens]} tokens (#{context[:window_source]})" if context[:window_tokens]
@@ -500,12 +516,31 @@ 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")
       end
 
+      # " (25.0% of the 64000 budget)" when the session's llm_context budget
+      # is set and smaller than the window, else " (12.5%)": the live meter
+      # counts against the smaller of the two (ContextStatus#counted_against),
+      # and so does this. The summary is Explained#summary (symbol or string
+      # keys: the attached TUI's come as JSON); "" when there is no window.
+      def context_pct_text(context, llm_context)
+        window = context[:window_tokens].to_i
+        return "" unless window.positive?
+
+        summary = llm_context.is_a?(Hash) ? llm_context : {}
+        budget = summary[:budget_tokens] || summary["budget_tokens"]
+        budget = nil unless budget.is_a?(Numeric) && budget.positive?
+        used = context[:used_tokens] * 100.0
+        return format(" (%.1f%%)", used / window) unless budget && budget < window
+
+        format(" (%.1f%% of the %d budget)", used / budget, budget)
+      end
+
       # "stale,forget (the session); apply turn_end (models: x); budget
       # 64000 (the session)" for /stats (Explained#summary; symbol or
       # string keys, the attached TUI's come as JSON); nil without one.

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]),