samagotchi 0.80.0 → 0.81.0

data/lib/samagotchi/session_metrics/side_totals.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../model_price"
+
+module Samagotchi
+  class SessionMetrics
+    # The sums over a session's side requests (SideUsage: an idle recap, a
+    # plugin's ctx.ask_model such as /btw), kept apart from its turns'
+    # Totals: the snapshot's and analytics.json's +side+ block, never in
+    # +tokens+ or +model_segments+. They have no records: the block itself
+    # is saved and loaded (#to_h, .from_saved).
+    # +cost_sum+ is nil until a request reports a cost (a reported 0
+    # included), +cost_estimate_sum+ 0 until one is estimated from a price
+    # (ModelPrice.estimate, the turns' rule). +by_kind+ is a frozen Hash
+    # kind => {requests:, cost_sum:, cost_estimate_sum:} in first-seen order.
+    class SideTotals < Data.define(:requests, :prompt_sum, :completion_sum, :cached_sum, :cache_write_sum,
+                                   :reasoning_sum, :cost_sum, :cost_estimate_sum, :by_kind)
+      # The counts summed as they are (the costs and by_kind apart).
+      COUNTS = %i[requests prompt_sum completion_sum cached_sum cache_write_sum reasoning_sum].freeze
+
+      def self.zero
+        new(**COUNTS.to_h { |key| [key, 0] }, cost_sum: nil, cost_estimate_sum: 0, by_kind: {}.freeze)
+      end
+
+      # The block as analytics.json saved it (string keys): a non-Hash is
+      # zero totals, a missing or non-numeric count 0, a missing or null
+      # cost_sum nil.
+      # @param hash [Hash, nil]
+      # @return [SideTotals]
+      def self.from_saved(hash)
+        return zero unless hash.is_a?(Hash)
+
+        hash = hash.transform_keys(&:to_s)
+        kinds = hash["by_kind"].is_a?(Hash) ? hash["by_kind"] : {}
+        new(**COUNTS.to_h { |key| [key, count(hash[key.to_s])] }, cost_sum: cost(hash["cost_sum"]),
+                                                                  cost_estimate_sum: number(hash["cost_estimate_sum"]),
+                                                                  by_kind: kinds.each_with_object({}) do |(kind, row), rows|
+                                                                    row = row.is_a?(Hash) ? row.transform_keys(&:to_s) : {}
+                                                                    rows[kind.to_s] = { requests: count(row["requests"]), cost_sum: cost(row["cost_sum"]),
+                                                                                        cost_estimate_sum: number(row["cost_estimate_sum"]) }.freeze
+                                                                  end.freeze)
+      end
+
+      # These totals with one side request counted in.
+      # @param usage [SideUsage]
+      # @return [SideTotals]
+      def add(usage)
+        estimate = ModelPrice.estimate(usage.price, reported_cost: usage.cost, prompt_tokens: usage.prompt_tokens,
+                                                    cached_tokens: usage.cached_tokens,
+                                                    cache_write_tokens: usage.cache_write_tokens,
+                                                    completion_tokens: usage.completion_tokens)
+        one = { requests: 1, cost_sum: usage.cost&.to_f, cost_estimate_sum: estimate || 0 }
+        kind = usage.kind.to_s
+        rows = by_kind.merge(kind => sum_row(by_kind[kind], one))
+        with(requests: requests + 1, prompt_sum: prompt_sum + usage.prompt_tokens.to_i,
+             completion_sum: completion_sum + usage.completion_tokens.to_i,
+             cached_sum: cached_sum + usage.cached_tokens.to_i,
+             cache_write_sum: cache_write_sum + usage.cache_write_tokens.to_i,
+             reasoning_sum: reasoning_sum + usage.reasoning_tokens.to_i,
+             cost_sum: add_cost(cost_sum, one[:cost_sum]),
+             cost_estimate_sum: cost_estimate_sum + one[:cost_estimate_sum], by_kind: rows.freeze)
+      end
+
+      # These totals with +other+'s added (a loaded block and the requests
+      # counted before the load); the kinds in first-seen order, these first.
+      # @param other [SideTotals]
+      # @return [SideTotals]
+      def merge(other)
+        rows = other.by_kind.each_with_object(by_kind.dup) { |(kind, row), all| all[kind] = sum_row(all[kind], row) }
+        with(**COUNTS.to_h { |key| [key, public_send(key) + other.public_send(key)] },
+             cost_sum: add_cost(cost_sum, other.cost_sum),
+             cost_estimate_sum: cost_estimate_sum + other.cost_estimate_sum, by_kind: rows.freeze)
+      end
+
+      def empty? = requests.zero?
+
+      # The snapshot's side block (symbol keys; by_kind keyed by kind).
+      # @return [Hash]
+      def to_h
+        counts = COUNTS.to_h { |key| [key, public_send(key)] }
+        counts.merge(cost_sum: cost_sum, cost_estimate_sum: cost_estimate_sum, by_kind: by_kind.transform_values(&:dup))
+      end
+
+      def self.count(value) = value.is_a?(Numeric) ? value.to_i : 0
+
+      def self.number(value) = value.is_a?(Numeric) ? value : 0
+
+      def self.cost(value) = value.is_a?(Numeric) ? value : nil
+
+      private_class_method :count, :number, :cost
+
+      private
+
+      def sum_row(row, one)
+        return one.dup.freeze unless row
+
+        { requests: row[:requests] + one[:requests], cost_sum: add_cost(row[:cost_sum], one[:cost_sum]),
+          cost_estimate_sum: row[:cost_estimate_sum] + one[:cost_estimate_sum] }.freeze
+      end
+
+      # nil + nil stays nil (no cost reported yet); a reported one sums.
+      def add_cost(left, right)
+        return left if right.nil?
+        return right if left.nil?
+
+        left + right
+      end
+    end
+  end
+end

data/lib/samagotchi/session_metrics.rb

@@ -12,6 +12,8 @@ require_relative "model_price"
 require_relative "session"
 require_relative "session_metrics/totals"
 require_relative "session_metrics/model_segment"
+require_relative "session_metrics/side_totals"
+require_relative "side_usage"
 
 module Samagotchi
   # SessionMetrics is a persistent, error-isolated collector of per-session
@@ -65,11 +67,14 @@ module Samagotchi
     # nil when an older file has none.
     # cost_estimate_sum: the estimated cost (hosts.<name>.models prices), 0
     # in an older file.
+    # side: the side requests' block (SideTotals#to_h as saved, string
+    # keys), nil when the session made none (or an older file).
     SavedSummary = Data.define(:ctx_pct, :prompt_sum, :completion_sum, :cached_sum, :reasoning_sum, :cost_sum,
-                               :cost_estimate_sum, :memory_index) do
-      def initialize(memory_index: nil, cost_estimate_sum: 0, **) = super
+                               :cost_estimate_sum, :memory_index, :side) do
+      def initialize(memory_index: nil, cost_estimate_sum: 0, side: nil, **) = super
 
-      def tokens = to_h.except(:ctx_pct, :memory_index)
+      # The turns' token totals (the side requests' are #side, apart).
+      def tokens = to_h.except(:ctx_pct, :memory_index, :side)
     end
 
     # Per-turn transient state, reset on each turn_started.
@@ -199,7 +204,8 @@ module Samagotchi
                        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)
+                       memory_index: data["memory_index"].is_a?(Hash) ? data["memory_index"] : nil,
+                       side: data["side"].is_a?(Hash) ? data["side"] : nil)
     rescue TypeError
       nil
     end
@@ -267,6 +273,10 @@ module Samagotchi
 
     def initialize(clock: nil, wall_clock: nil)
       @mutex = Monitor.new
+      # Serializes #persist (snapshot and write), so two threads' saves land
+      # in snapshot order. Taken before @mutex, never under it: the write's
+      # IO doesn't hold up the events.
+      @persist_mutex = Mutex.new
       @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       @wall_clock = wall_clock || -> { Time.now }
       @session_id = nil
@@ -281,6 +291,9 @@ module Samagotchi
       # and how many were loaded (a woken collector's live records start empty).
       @persisted_turns = 0
       @loaded_turns = 0
+      # The side requests' sums: not in reset_totals, which a load's recount
+      # of the turn records calls (side requests have no records).
+      @side = SideTotals.zero
       reset_totals
     end
 
@@ -338,6 +351,17 @@ module Samagotchi
       end
     end
 
+    # Count one side request (a recap, a plugin's ctx.ask_model) in the
+    # side block, apart from the turns' totals. Safe from any thread.
+    # @param usage [SideUsage]
+    # @return [Hash] the side block now (SideTotals#to_h)
+    def add_side(usage)
+      @mutex.synchronize do
+        @side = @side.add(usage)
+        @side.to_h
+      end
+    end
+
     # Event sink. Safe to call from any thread; errors are isolated by the
     # caller (SessionObserver / TerminalUI) but we still guard internally.
     # @param event [Hash]
@@ -454,6 +478,15 @@ module Samagotchi
     #   turn's own end writes over it. Only the file has it.
     # @return [Boolean] true on success
     def persist(state_dir: nil, running_turn: false)
+      @persist_mutex.synchronize { persist_now(state_dir, running_turn) }
+    rescue StandardError
+      false
+    end
+
+    private
+
+    # #persist's work, under the persist mutex.
+    def persist_now(state_dir, running_turn)
       sid, data, turn_count = @mutex.synchronize do
         data = build_snapshot(:all).merge(active_turn: nil, active_tools: [])
         if running_turn && @turn
@@ -471,12 +504,8 @@ module Samagotchi
       AtomicFile.write(AnalyticsFile.path(dir), JSON.pretty_generate(data) + "\n")
       @mutex.synchronize { @persisted_turns = [@persisted_turns, turn_count].max }
       true
-    rescue StandardError
-      false
     end
 
-    private
-
     # Caller holds the mutex. +records+: :recent (the live snapshot) or :all
     # (analytics.json).
     def build_snapshot(records_mode)
@@ -502,6 +531,9 @@ module Samagotchi
         # The calls the model made under an alias's name (bash run as
         # execute), by its own spelling; only when there are any.
         **(@tool_tallies[:aliased].empty? ? {} : { tool_calls_aliased: @tool_tallies[:aliased].dup }),
+        # The side requests (recap, ctx.ask_model), apart from +tokens+;
+        # only when there were any.
+        **(@side.empty? ? {} : { side: @side.to_h }),
         tool_errors: @tool_tallies[:errors],
         iterations_total: totals.iterations,
         gen_latency_ms: totals.gen_ms.round,
@@ -791,10 +823,10 @@ module Samagotchi
       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
+      estimate = ModelPrice.estimate(turn.gen_price, reported_cost: turn.gen_cost, prompt_tokens: turn.gen_prompt_max,
+                                                     cached_tokens: turn.gen_cached_max,
+                                                     cache_write_tokens: turn.gen_cache_write_max, completion_tokens: completion)
+      turn.cost_estimate_sum += estimate if estimate
       turn.last_prefill_tps = turn.gen_prefill_tps.round(1) if turn.gen_prefill_tps
       speed = generation_speed(turn, completion)
       return unless speed
@@ -1098,6 +1130,8 @@ module Samagotchi
       end
       # The indexes the prompt last held, until this process builds its own.
       @memory_index ||= symbolized(prior["memory_index"]) if prior["memory_index"].is_a?(Hash)
+      # The saved side block, with any counted before the load after it.
+      @side = SideTotals.from_saved(prior["side"]).merge(@side)
       # The window last seen, until this process's first generation reports.
       window = prior["context"].is_a?(Hash) ? prior["context"] : {}
       return unless window["window_tokens"] && @context_window_tokens.nil?

data/lib/samagotchi/session_observer.rb

@@ -22,6 +22,9 @@ module Samagotchi
   #   * recap_ready — an idle session-recap finished generating
   #     (`recap:` prose, `generation:` id). Purely additive: it never mutates
   #     session.messages; each UI renders it (or not) however it likes.
+  #   * side_usage — a side request (the recap, a plugin's ctx.ask_model) was
+  #     counted (Engine#note_side_usage): `kind:` and `side:`, the session's
+  #     whole side block (SessionMetrics#add_side), in fold order.
   class SessionObserver
     # Handle returned by #subscribe. Holds the observer reference and carries
     # #unsubscribe so a caller can deregister without keeping the registry.

data/lib/samagotchi/side_usage.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # One side request's usage (an idle recap, a plugin's ctx.ask_model such
+  # as /btw): what IdleClient reports to its on_usage callback and
+  # SessionMetrics#add_side folds into the session's side line, apart from
+  # its turns' totals.
+  # @!attribute kind [String] "recap", or the asking bundle's name ("btw")
+  # @!attribute model [String] the target's model, for the log
+  # @!attribute prompt_tokens [Integer] 0 when not reported (and the rest)
+  # @!attribute completion_tokens [Integer]
+  # @!attribute cached_tokens [Integer]
+  # @!attribute cache_write_tokens [Integer]
+  # @!attribute reasoning_tokens [Integer]
+  # @!attribute cost [Float, nil] the provider's reported cost (OpenRouter's
+  #   usage.cost), nil when not reported
+  # @!attribute price [ModelPrice, nil] the target host's price for the
+  #   model (IdleTarget#price), what the cost is estimated from
+  SideUsage = Data.define(:kind, :model, :prompt_tokens, :completion_tokens, :cached_tokens, :cache_write_tokens,
+                          :reasoning_tokens, :cost, :price) do
+    def initialize(kind:, model: nil, prompt_tokens: 0, completion_tokens: 0, cached_tokens: 0, cache_write_tokens: 0,
+                   reasoning_tokens: 0, cost: nil, price: nil)
+      super
+    end
+
+    # A response's usage (LLM::Usage; Usage.none's zeros when the server
+    # reported no counts: still one request) as a side request's.
+    # @param usage [LLM::Usage, nil]
+    # @return [SideUsage]
+    def self.from_usage(usage, kind:, model:, price:)
+      count = ->(name) { usage.respond_to?(name) ? usage.public_send(name).to_i : 0 }
+      new(kind: kind.to_s, model: model, prompt_tokens: count.call(:prompt_tokens),
+          completion_tokens: count.call(:completion_tokens), cached_tokens: count.call(:cached_tokens),
+          cache_write_tokens: count.call(:cache_write_tokens), reasoning_tokens: count.call(:reasoning_tokens),
+          cost: usage.respond_to?(:cost) ? usage.cost : nil, price: price)
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -594,6 +594,9 @@ module Samagotchi
         lines << "speed:            #{speed}" if speed
         cost = stats_cost_text(tokens, price_host: snapshot[:price_host], per_model: segments.size >= 2)
         lines << "cost:             #{cost}" if cost
+        # The side requests, never in the totals above.
+        side = side_requests_text(snapshot[:side])
+        lines << "side requests:    #{side} (not in the totals above)" unless side.empty?
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
         lines << "retries:          #{snapshot[:retries]}"

data/lib/samagotchi/terminal_ui/model_segments_text.rb

@@ -5,9 +5,11 @@ require_relative "../memory_bundle/index_size"
 
 module Samagotchi
   class TerminalUI
-    # A session's rows per model in /stats (the snapshot's model_segments).
-    # The four public model_segment_* labels are the words the web's ctx
-    # tooltip shares (ctx.js; spec/shared/labels_matrix.json model_segments).
+    # A session's rows per model in /stats (the snapshot's model_segments),
+    # and its side requests' line (the snapshot's side block).
+    # The four public model_segment_* labels and side_requests_text are the
+    # words the web's ctx tooltip shares (ctx.js;
+    # spec/shared/labels_matrix.json model_segments, side_requests).
     # Rows come symbol- or string-keyed (the attached TUI's as JSON).
     # Included by Formatting, whose cost_text and speed_text it uses.
     module ModelSegmentsText
@@ -34,6 +36,28 @@ module Samagotchi
           .reject(&:empty?).join(" + ")
       end
 
+      # "3 (recap 2, btw 1) · 14.2k in / 380 out · $0.0012 + ~$0.0009": the
+      # side requests (the snapshot's side block: the recap, /btw and other
+      # ctx.ask_model calls), the kinds in first-seen order (one kind: its
+      # name alone), then the model rows' tokens and cost words on the
+      # block; "" without any (the line is hidden).
+      def side_requests_text(side)
+        return "" unless side.is_a?(Hash)
+
+        count = segment_value(side, :requests).to_i
+        return "" unless count.positive?
+
+        kinds = segment_value(side, :by_kind)
+        kinds = {} unless kinds.is_a?(Hash)
+        names = if kinds.size == 1
+                  kinds.keys.first.to_s
+                else
+                  kinds.map { |kind, row| "#{kind} #{(row.is_a?(Hash) ? segment_value(row, :requests) : 0).to_i}" }.join(", ")
+                end
+        head = names.empty? ? count.to_s : "#{count} (#{names})"
+        [head, model_segment_tokens_text(side), model_segment_cost_text(side)].reject(&:empty?).join(" · ")
+      end
+
       # "switch prefill 3.0k uncached prompt ≈$0.0060": what the switch to the
       # row's model prefilled (its cost an estimate from the configured
       # price, left out without one); "" for none.

data/lib/samagotchi/testing/host.rb

@@ -31,9 +31,9 @@ module Samagotchi
           },
           cancelled: -> { recorder[:cancelled] },
           card: ->(**card) { recorder.card(**card) },
-          ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:, model: nil|
+          ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:, model: nil, source: nil|
             recorder.ask_model(request, timeout: timeout, max_tokens: max_tokens, cancel_controller: cancel_controller,
-                                        model: model)
+                                        model: model, source: source)
           },
           model_name: -> { recorder[:model_name] },
           model_key: -> { recorder[:model_key] },

data/lib/samagotchi/testing/recorder.rb

@@ -16,8 +16,11 @@ module Samagotchi
     Question = Data.define(:question, :options, :header, :allow_freeform, :hook)
     # An ask_model request: the request Context built (SideQuestion), its
     # limits, cancel controller and the model: it named (nil: the session's;
-    # the kit doesn't check it against any hosts).
-    ModelRequest = Data.define(:request, :timeout, :max_tokens, :cancel, :model)
+    # the kit doesn't check it against any hosts), and +source+, the asking
+    # bundle's name (what chi counts its side request under).
+    ModelRequest = Data.define(:request, :timeout, :max_tokens, :cancel, :model, :source) do
+      def initialize(source: nil, **) = super
+    end
 
     # What a bundle did at chi's edges, for a test to read: the Engine side
     # of its Context (Testing::Host) and the hook runtime (Testing::Runtime)
@@ -104,9 +107,9 @@ module Samagotchi
       # The next queued model answer (#model_answers): a String, an
       # exception to raise, or a callable given the ModelRequest. None left:
       # Plugin::ModelError, as an unreachable model.
-      def ask_model(request, timeout:, max_tokens:, cancel_controller:, model: nil)
+      def ask_model(request, timeout:, max_tokens:, cancel_controller:, model: nil, source: nil)
         entry = ModelRequest.new(request: request, timeout: timeout, max_tokens: max_tokens, cancel: cancel_controller,
-                                 model: model)
+                                 model: model, source: source)
         record(@model_requests, entry)
         answer = @mutex.synchronize { @model_answers.empty? ? :none : @model_answers.shift }
         raise Plugin::ModelError, "no model answer queued (bundle.model_answers << \"text\")" if answer == :none

data/lib/samagotchi/testing/sandbox.rb

@@ -9,8 +9,8 @@ require_relative "fake_executable"
 
 module Samagotchi
   module Testing
-    # The environment a bundle test runs in: temp config and state homes
-    # (config.yml, memories, ctx.data_dir, the debug log), HOME and the peer
+    # The environment a bundle test runs in: temp config, state, data and cache
+    # homes (config.yml, memories, ctx.data_dir, the debug log), HOME and the peer
     # CLIs' folders, git without the user's config, no Keychain, none of
     # the user's SAMAGOTCHI_* settings, a bin/ first on PATH for fake
     # commands. ENV is put back on #leave.
@@ -59,12 +59,14 @@ module Samagotchi
         @saved = ENV.to_h
         @outer = Sandbox.current
         ENV.each_key.select { |key| key.start_with?("SAMAGOTCHI_") && !KEPT.include?(key) }.each { |key| ENV.delete(key) }
-        %w[config state home work bin].each { |dir| FileUtils.mkdir_p(File.join(@root, dir)) }
+        %w[config state data cache home work bin].each { |dir| FileUtils.mkdir_p(File.join(@root, dir)) }
         File.write(File.join(@root, "gitconfig"), "")
         ENV.update(
           "HOME" => File.join(@root, "home"),
           "XDG_CONFIG_HOME" => File.join(@root, "config"),
           "XDG_STATE_HOME" => File.join(@root, "state"),
+          "XDG_DATA_HOME" => File.join(@root, "data"),
+          "XDG_CACHE_HOME" => File.join(@root, "cache"),
           "CLAUDE_CONFIG_DIR" => File.join(@root, "home", ".claude"),
           "CODEX_HOME" => File.join(@root, "home", ".codex"),
           "GIT_CONFIG_GLOBAL" => File.join(@root, "gitconfig"),

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.80.0"
+  VERSION = "0.81.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -1798,7 +1798,10 @@ module Samagotchi
           # model_segments; none with one model, or from an older file).
           model_segments: Array(source["model_segments"]),
           # The memory indexes the session's prompt holds (the ctx tooltip).
-          memory_index: source["memory_index"]
+          memory_index: source["memory_index"],
+          # The side requests (recap, /btw, ctx.ask_model), apart from the
+          # tokens: the ctx tooltip's own line (nil without any).
+          side: source["side"]
         }
       end
 

data/lib/samagotchi/web/public/ctx.js

@@ -142,14 +142,19 @@ export function ctxBarText(pct, windowSource = null) {
 // bar's; a /model whose new window didn't resolve, no request since:
 // Engine#announce_switched_context! sent usage null) adds "until the next
 // request", which asks for it again.
-export function ctxBarTip(tokens, memoryIndex, window, segments = null) {
+// +side+ (the timing's side block) adds the side requests' line, in the
+// "No request in this session yet" answer too (a /btw before any turn).
+export function ctxBarTip(tokens, memoryIndex, window, segments = null, side = null) {
   if (num(window?.pct) === null) {
-    if (!num(tokens?.prompt_sum) && !num(tokens?.completion_sum)) return "No request in this session yet";
+    if (!num(tokens?.prompt_sum) && !num(tokens?.completion_sum)) {
+      const sideText = sideRequestsText(side);
+      return `No request in this session yet${sideText ? `\nside requests: ${sideText}` : ""}`;
+    }
     const why = window?.afterSwitch ? "Context window unknown until the next request" : "Context window unknown";
-    return tokensTipText(tokens, why, memoryIndex, null, segments);
+    return tokensTipText(tokens, why, memoryIndex, null, segments, side);
   }
 
-  return tokensTipText(tokens, undefined, memoryIndex, window, segments);
+  return tokensTipText(tokens, undefined, memoryIndex, window, segments, side);
 }
 
 // The ctx tooltip's window line ({tokens:, source:, pct:, budget:} the
@@ -198,6 +203,24 @@ export function modelSegmentCostText(row) {
   return [costText(row?.cost_sum), costText(row?.cost_estimate_sum, { estimate: true })].filter(Boolean).join(" + ");
 }
 
+// "3 (recap 2, btw 1) · 14.2k in / 380 out · $0.0012 + ~$0.0009": the
+// session's side requests (the timing's side block: the idle recap, /btw and
+// other ctx.ask_model calls, apart from its turns' totals), the kinds in
+// first-seen order (one kind: its name alone), then the model rows' tokens
+// and cost words on the block; "" without any (the line is hidden). As
+// Formatting#side_requests_text (spec/shared/labels_matrix.json side_requests).
+export function sideRequestsText(side) {
+  if (!side || typeof side !== "object") return "";
+  const requests = num(side.requests) || 0;
+  if (requests <= 0) return "";
+  const kinds = side.by_kind && typeof side.by_kind === "object" ? Object.entries(side.by_kind) : [];
+  const names = kinds.length === 1
+    ? kinds[0][0]
+    : kinds.map(([kind, row]) => `${kind} ${Math.round(num(row?.requests) || 0)}`).join(", ");
+  const head = names ? `${Math.round(requests)} (${names})` : String(Math.round(requests));
+  return [head, modelSegmentTokensText(side), modelSegmentCostText(side)].filter(Boolean).join(" · ");
+}
+
 // "switch prefill 3.0k uncached prompt ≈$0.0060": what the switch to the
 // row's model prefilled (its cost an estimate from the configured price,
 // left out without one); "" for none.
@@ -246,14 +269,16 @@ function modelSegmentLines(segments) {
 // totals. A delegated session keeps its own metrics, so these are this
 // session's only.
 export function tokensTipText(tokens, title = "Context used after the last turn", memoryIndex = null, window = null,
-                              segments = null) {
+                              segments = null, side = null) {
   const memory = memoryIndexText(memoryIndex);
   const memoryLine = memory ? `\nmemory index: ${memory}` : "";
+  const sideText = sideRequestsText(side);
+  const sideLine = sideText ? `side requests: ${sideText}` : "";
   const windowText = ctxWindowText(window);
   if (windowText) title = `${title}\n${windowText}`;
   const prompt = num(tokens?.prompt_sum) || 0;
   const completion = num(tokens?.completion_sum) || 0;
-  if (!prompt && !completion) return `${title}${memoryLine}`;
+  if (!prompt && !completion) return `${title}${sideLine ? `\n${sideLine}` : ""}${memoryLine}`;
   const cached = num(tokens.cached_sum) || 0;
   const reasoning = num(tokens.reasoning_sum) || 0;
   const parts = [`in ${count(prompt)}`];
@@ -262,6 +287,7 @@ export function tokensTipText(tokens, title = "Context used after the last turn"
   const lines = [title, ...modelSegmentLines(segments), `tokens: ${parts.join(" · ")}`];
   const cost = costLine(tokens);
   if (cost) lines.push(cost);
+  if (sideLine) lines.push(sideLine);
   lines.push("this session only, all requests");
   return `${lines.join("\n")}${memoryLine}`;
 }

data/lib/samagotchi/web/public/info_bar_model.js

@@ -68,7 +68,7 @@ export function infoBarModel({ id, state, sessions, chain, cardTitle, badge, res
   const ctxTip = ctxBarTip(tokens, state.timing.memoryIndex,
                            { tokens: state.ctxWindow, source: state.ctxWindowSource, pct: state.ctxPct,
                              budget: state.llmContext?.budget_tokens, afterSwitch: state.ctxUnknownAfterSwitch },
-                           state.timing.modelSegments);
+                           state.timing.modelSegments, state.timing.side);
   const speedTextNow = lastSpeedText(tokens);
   const avgSpeed = speedText(tokens?.avg_decode_tps, tokens?.tps_source);
   const sessionDuration = sessionDurationNow(state.timing, running);

data/lib/samagotchi/web/public/lists_view.js

@@ -145,7 +145,7 @@ export function cardTemplate(s, { deletable = false, archivable = false, selecta
   const folderT = folder ? html`<span class="folder" title=${s.working_directory}>${folder}</span>` : nothing;
   const archived = s.archived ? html`<span class="archived-badge" title="Archived: hidden from the lists, kept for good">archived</span>` : nothing;
   const ctx = cardCtxText(s.ctx_pct);
-  const ctxT = ctx ? html`<span class="ctx" title=${ctxBarTip(s.tokens, s.memory_index, { pct: s.ctx_pct })}>${ctx}</span>` : nothing;
+  const ctxT = ctx ? html`<span class="ctx" title=${ctxBarTip(s.tokens, s.memory_index, { pct: s.ctx_pct }, null, s.side)}>${ctx}</span>` : nothing;
   const waiting = waitingBadge(s);
   const waitingT = waiting ? html`<span class=${`attn attn-${waiting.kind}`} title=${waiting.title}>${waiting.text}</span>` : nothing;
   // A turn a hook stopped wears its own badge, unless the session waits on

data/lib/samagotchi/web/public/stream_handlers.js

@@ -339,6 +339,13 @@ export function createStreamHandlers(deps) {
     question_cancelled: (data) => {
       questionCards.resolveQuestion(data.id, { cancelled: true, reason: data.reason });
     },
+    // A side request (the recap, /btw, a plugin's ctx.ask_model) counted:
+    // the server's whole side block, for the ctx tooltip's line at once.
+    side_usage: (data) => {
+      if (!data?.side || typeof data.side !== "object") return;
+      state().timing.side = data.side;
+      updateInfoBar();
+    },
     // One collected just as a turn started describes the chat before it.
     recap_ready: (data) => {
       // After the turn it covers, never above it.

data/lib/samagotchi/web/public/timing.js

@@ -85,6 +85,10 @@ export function normalizeTiming(data = {}) {
     // (SessionMetrics' model_segments; [] with one model), for the ctx
     // tooltip.
     modelSegments: Array.isArray(data.model_segments) ? data.model_segments.filter(validRecord) : [],
+    // The session's side requests (SessionMetrics' side block: recap,
+    // /btw, ctx.ask_model, apart from tokens), for the ctx tooltip; null
+    // without any.
+    side: validRecord(data.side) ? data.side : null,
   };
 }
 
@@ -121,11 +125,12 @@ export function mergeTiming(timing, data = {}) {
   });
   const tokens = fresh.tokens || timing?.tokens || null;
   const memoryIndex = fresh.memoryIndex || timing?.memoryIndex || null;
+  const side = fresh.side || timing?.side || null;
   // A reply that has the rows is the answer, an empty list too (one model
   // now): a stale list never survives it; one without them (an older
   // server) keeps the page's.
   const modelSegments = data && "model_segments" in data ? fresh.modelSegments : (timing?.modelSegments || []);
-  return { timing: { ...fresh, turnRecords, toolRecords, tokens, memoryIndex, modelSegments },
+  return { timing: { ...fresh, turnRecords, toolRecords, tokens, memoryIndex, modelSegments, side },
            short: turnRecords.length < count };
 }
 

data/lib/samagotchi/web/session_summary.rb

@@ -77,6 +77,8 @@ module Samagotchi
           tokens: saved&.tokens,
           # The memory indexes its prompt held (the card's ctx tooltip).
           memory_index: saved&.memory_index,
+          # Its side requests, apart from the tokens (the tooltip's own line).
+          side: saved&.side,
           # Hidden from the strip and the list unless "include archived".
           archived: ArchiveStore.archived?(session_dir),
           project_root: session.project_root(cache: root_cache),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.80.0
+  version: 0.81.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -292,6 +292,7 @@ files:
 - lib/samagotchi/guardrails/approvals.rb
 - lib/samagotchi/guardrails/child_boundary.rb
 - lib/samagotchi/guardrails/context.rb
+- lib/samagotchi/guardrails/data_readers.rb
 - lib/samagotchi/guardrails/gate.rb
 - lib/samagotchi/guardrails/load_failures.rb
 - lib/samagotchi/guardrails/model_size.rb
@@ -469,6 +470,7 @@ files:
 - lib/samagotchi/session_manager.rb
 - lib/samagotchi/session_metrics.rb
 - lib/samagotchi/session_metrics/model_segment.rb
+- lib/samagotchi/session_metrics/side_totals.rb
 - lib/samagotchi/session_metrics/totals.rb
 - lib/samagotchi/session_model_settings.rb
 - lib/samagotchi/session_observer.rb
@@ -477,6 +479,7 @@ files:
 - lib/samagotchi/session_setup.rb
 - lib/samagotchi/sessions_command.rb
 - lib/samagotchi/setting_explained.rb
+- lib/samagotchi/side_usage.rb
 - lib/samagotchi/steer.rb
 - lib/samagotchi/steer_cut.rb
 - lib/samagotchi/steer_cut_after.rb