samagotchi 0.45.0 → 0.46.1

data/lib/samagotchi/session_commands.rb

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

data/lib/samagotchi/session_metrics.rb

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

data/lib/samagotchi/terminal_ui/attached_view.rb

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

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -96,14 +96,29 @@ module Samagotchi
         paint(TurnNote.empty_answer_line(retries), 90)
       end
 
-      # "retrying (1/3 in 0.5s): Errno::ECONNREFUSED": the retry of all the
-      # retries there will be (as the web counts), the wait before it, and
-      # what failed (generation_retrying).
+      # "↻ retrying (503) in 4.0s, 2/5": the live status while the provider
+      # is asked again (generation_retrying), worded as the web words it
+      # (turn_events.js retryStatusLine; spec/shared/labels_matrix.json):
+      # why (the HTTP status, the error's short class name, or "stream
+      # dropped" for a dropped stream's step asked again), the wait before
+      # it, and the retry of all the retries there will be.
       def format_generation_retry_line(event)
-        return "retrying (attempt #{event[:attempt]})" unless event[:max_retries]
+        why = event[:restarted] ? "stream dropped" : retry_cause(event)
+        delay = Float(event[:next_delay], exception: false)
+        text = +"\u21bb retrying"
+        text << " (#{why})" unless why.empty?
+        text << " in #{format("%.1f", (delay * 10).round / 10.0)}s" if delay&.finite?
+        text << ", #{event[:attempt]}#{"/#{event[:max_retries]}" if event[:max_retries]}" if event[:attempt]
+        text
+      end
+
+      # What failed, for a retry line: the HTTP status, else the error's
+      # class name without its namespace (Errno::ECONNREFUSED: ECONNREFUSED).
+      def retry_cause(event)
+        status = event[:status]
+        return status.to_s unless status.nil? || status.to_s.empty? || status.to_s == "0"
 
-        text = "retrying (#{event[:attempt]}/#{event[:max_retries]} in #{format("%.1f", event[:next_delay].to_f)}s)"
-        event[:error_class].to_s.empty? ? text : "#{text}: #{event[:error_class]}"
+        event[:error_class].to_s.split("::").last.to_s
       end
 
       # " → image 1280×800" after a tool line whose tool read an image.
@@ -342,13 +357,28 @@ 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.
+      # +price_host+ names the host whose hosts.<name>.models prices the
+      # estimate came from (Engine#stats_snapshot; nil from an older worker).
+      def stats_cost_text(tokens, price_host: nil)
+        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?
+
+        source = price_host.to_s.empty? ? "configured prices" : "hosts.#{price_host}.models prices"
+        estimate = "#{estimated} from #{source}"
+        "#{reported.empty? ? estimate : "#{reported} reported + #{estimate}"} (this session only)"
       end
 
       private
@@ -411,9 +441,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 +507,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, price_host: snapshot[:price_host])
+        lines << "cost:             #{cost}" if cost
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
         lines << "retries:          #{snapshot[:retries]}"
@@ -500,7 +531,8 @@ module Samagotchi
         lines << "llm context:      #{llm_context}" if llm_context
         if snapshot[:served_model]
           asked = snapshot[:served_model_for]
-          note = ServedModel.differs?(asked, snapshot[:served_model]) ? " (asked for #{asked})" : ""
+          differs = !snapshot[:served_expected_by] && ServedModel.differs?(asked, snapshot[:served_model])
+          note = differs ? " (asked for #{asked})" : ""
           lines << "served model:     #{snapshot[:served_model]}#{note}"
         end
         lines.join("\n")

data/lib/samagotchi/terminal_ui/status_row.rb

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

data/lib/samagotchi/terminal_ui.rb

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

data/lib/samagotchi/tools/delegate_wait.rb

@@ -84,10 +84,11 @@ module Samagotchi
           outcomes << outcome.line
           return with_outcomes(canceled_result(child_id, reports: reports), outcomes) if outcome.stopped
 
-          # Wait on with the child as it is now: a turn that ends with no
-          # reply after the relay still ends the wait, and the relayed
-          # question isn't reported again.
-          baseline = ReplyWait.baseline_of(Session.load(child_id, state_dir: sd), question_id: wait.question[:id])
+          # Wait on from the child as it was before the relay (read when it
+          # asked), the relayed question no longer reported: a turn that
+          # ends with no reply during the relay's POST or after it still
+          # ends the wait.
+          baseline = ReplyWait.baseline_of(wait.session, question_id: wait.question[:id])
         end
       rescue ArgumentError => e
         "Error: #{e.message}"

data/lib/samagotchi/tools/task_runtime.rb

@@ -66,6 +66,8 @@ module Samagotchi
           err: output_io
         )
         Process.detach(pid)
+        # Read now, compared before each signal: a pid reused later is not this task.
+        pid_started = ProcessGroup.start_time(pid)
 
         now = timestamp
         record = {
@@ -76,6 +78,7 @@ module Samagotchi
           "workspace_root" => Dir.pwd,
           "status" => "running",
           "pid" => pid,
+          "pid_started" => pid_started,
           "created_at" => now,
           "started_at" => now,
           "finished_at" => nil,
@@ -190,7 +193,7 @@ module Samagotchi
 
         pid = refreshed["pid"]
         # Checked again just before the signal: never a group chi didn't start.
-        return [mark_not_chis(refreshed), nil] unless ProcessGroup.leader?(pid)
+        return [mark_not_chis(refreshed), nil] unless chis_group?(refreshed, started: refreshed["pid_started"])
 
         refreshed["stop_requested_by"] = by.to_s
         write_record(refreshed)
@@ -210,13 +213,19 @@ module Samagotchi
         return record unless record["status"] == "running"
 
         pid = record["pid"]
-        return record if ProcessGroup.leader?(pid)
+        return record if chis_group?(record)
         # Gone: its exit code says how it ended.
         return mark_finished_without_exit_code(record) if ProcessGroup.signalable?(pid) && !ProcessGroup.alive?(pid)
 
         mark_not_chis(record)
       end
 
+      # Whether the record's pid still leads its own group. With +started+
+      # (the start time recorded at task_create), also the same process: a
+      # ps per call, so only task_stop asks it, just before the signal;
+      # a refresh (each task_wait poll, task_list) checks the group only.
+      def chis_group?(record, started: nil) = ProcessGroup.leader?(record["pid"], started: started)
+
       # A running record whose pid isn't a group chi started (NOT_CHIS_PROCESS)
       # ends as failed, unless its exit code or a stop on disk says more.
       def mark_not_chis(record)

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -24,6 +24,7 @@ require_relative "../llm_context_override"
 require_relative "../model_catalog"
 require_relative "../model_profile"
 require_relative "../sampling_settings"
+require_relative "../served_model"
 require_relative "../project_scope"
 require_relative "../prompt_history"
 require_relative "../version"
@@ -443,7 +444,10 @@ module Samagotchi
             warnings.concat(listing.warnings)
             # the web's own spelling, kept as it was: bare on the default host
             listing.rows.each do |row|
-              models << { name: row.host == default_host ? row.id : "#{row.host}:#{row.id}", host: row.host, id: row.id }
+              model = { name: row.host == default_host ? row.id : "#{row.host}:#{row.id}", host: row.host, id: row.id }
+              model[:configured] = true if row.configured
+              model[:unavailable] = true if row.unavailable
+              models << model
             end
           end
         rescue StandardError => e
@@ -485,6 +489,33 @@ module Samagotchi
         nil
       end
 
+      # The served model a session's last generation reported (analytics.json,
+      # SessionMetrics#persist), for a session no worker runs: shown only
+      # while the name it answered is still the session's model, as
+      # Engine#served_model does, with the host whose served: expects it.
+      # {} when none applies.
+      def saved_served_model(session, persisted)
+        served = persisted["served_model"]
+        model = session.model_name.to_s
+        return {} unless served.is_a?(String) && !served.empty? && !model.empty?
+
+        registry = host_registry
+        asked = registry.bare_name(model)
+        return {} unless persisted["served_model_for"] == asked
+
+        { served_model: served, served_model_for: asked, served_expected_by: saved_served_expected_by(registry, model, served) }
+      rescue StandardError
+        {}
+      end
+
+      # See ServedModel.expected_by; nil when the model doesn't resolve (the
+      # mismatch still shows).
+      def saved_served_expected_by(registry, model, served)
+        ServedModel.expected_by(registry.resolve(model), served)
+      rescue StandardError
+        nil
+      end
+
       # A session's LLM context strategy, apply rule and budget, each with
       # where it came from (LLMContextStrategy::Explained#summary), as its
       # worker would resolve them; nil when they can't be.
@@ -655,17 +686,22 @@ module Samagotchi
         # A /model in the worker changes it before the file catches up.
         session.model_name = snapshot["model_name"] if snapshot && !snapshot["model_name"].to_s.empty?
         session_json = session_to_json(session, status: displayed_status(session, snapshot, owner: owner), owner: owner)
-        # What the worker's server said it served for that model (after a turn).
+        # What the worker's server said it served for that model (after a turn);
+        # without a worker, what the session's analytics.json last saved.
+        persisted = snapshot ? nil : read_analytics(id)
         if snapshot
-          session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"])
+          session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"],
+                                            served_expected_by: snapshot["served_expected_by"])
           # The model notes its prompt carries now (a /model there changes them).
           session_json = session_json.merge(prompt_notes: snapshot["prompt_notes"]) if snapshot["prompt_notes"].is_a?(Array)
+        else
+          session_json = session_json.merge(saved_served_model(session, persisted))
         end
         # The LLM context strategy the next turn runs under (the info bar's
         # chip): the worker's, else worked out here from the session file.
         session_json = session_json.merge(llm_context: (snapshot && snapshot["llm_context"]) || llm_context_for(session))
         raw_messages = turn_snapshot ? turn_snapshot["messages"] : session.messages
-        timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"])
+        timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
         json_response(200, {
           session: session_json,
           history: read_history(id),
@@ -1499,8 +1535,9 @@ module Samagotchi
 
       # The whole timing: analytics.json's records merged with a live
       # worker's (by id), and turn_count, the finished turns (#turn_count).
-      def timing_payload(session_id, live_metrics: nil)
-        persisted = read_analytics(session_id)
+      # +persisted+: the session's analytics.json when the caller read it.
+      def timing_payload(session_id, live_metrics: nil, persisted: nil)
+        persisted ||= read_analytics(session_id)
         live = live_metrics.is_a?(Hash)
         source = if live
                    persisted.merge(live_metrics).merge(

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

@@ -1156,7 +1156,7 @@ function renderSessionView(data) {
   setCapabilities(data.capabilities);
   current.status = s.status;
   current.model = s.model_name;
-  current.served = s.served_model ? [s.served_model, s.served_model_for] : null;
+  current.served = s.served_model ? [s.served_model, s.served_model_for, s.served_expected_by || null] : null;
   current.dir = s.working_directory;
   current.owner = s.owner || null;
   current.timing = normalizeTiming(data.timing);
@@ -2007,7 +2007,7 @@ const streamHandlers = {
   },
   generation_completed: (data) => {
     liveTurn.timing.setNote("");
-    if (data?.served_model) current.served = [data.served_model, data.requested_model];
+    if (data?.served_model) current.served = [data.served_model, data.requested_model, data.served_expected_by || null];
     // The generation's speed and the session's token totals, from the server.
     current.timing.tokens = generationTokens(current.timing.tokens, data);
     if (data?.served_model || data?.tokens) updateInfoBar();
@@ -2212,7 +2212,11 @@ const streamHandlers = {
   llm_context_edited: (data) => { turnDom.notice(llmContextNotice(data)); },
   // The provider is asked again after an error, or the turn waits for
   // plugins' setup: a note on the live timing line until it streams.
-  generation_retrying: (data) => liveTurn.timing.setNote(retryStatusLine(data)),
+  generation_retrying: (data) => {
+    // A dropped stream's step asked again: what it streamed is void.
+    if (data?.restarted) turnDom.generationRestarted(data);
+    liveTurn.timing.setNote(retryStatusLine(data));
+  },
   plugin_init_wait: (data) => liveTurn.timing.setNote(initWaitLine(data)),
   plugin_init_started: (data) => onInitEvent("plugin_init_started", data),
   plugin_init_finished: (data) => onInitEvent("plugin_init_finished", data),