samagotchi 0.74.0 → 0.76.0

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -435,17 +435,61 @@ module Samagotchi
       # /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)
+      # +per_model+: the session ran on several models (model_segments), each
+      # priced from its own host's prices.
+      def stats_cost_text(tokens, price_host: nil, per_model: false)
         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"
+        source = if per_model then "each model's host prices"
+                 elsif price_host.to_s.empty? then "configured prices"
+                 else "hosts.#{price_host}.models prices"
+                 end
         estimate = "#{estimated} from #{source}"
         "#{reported.empty? ? estimate : "#{reported} reported + #{estimate}"} (this session only)"
       end
 
+      # ── A session's rows per model (the snapshot's model_segments) ──────
+      # The words the web's ctx tooltip shares (ctx.js; spec/shared/
+      # labels_matrix.json model_segments). Rows come symbol- or
+      # string-keyed (the attached TUI's as JSON).
+
+      # A row's model: its ref; the rows folded past the cap ("3 earlier
+      # segments", told by folded_segments); a session's turns from before
+      # turns named their model ("earlier turns").
+      def model_segment_label(row)
+        folded = segment_value(row, :folded_segments).to_i
+        return "#{folded} earlier segments" if folded.positive?
+
+        ref = segment_value(row, :model_ref).to_s
+        ref.empty? ? "earlier turns" : ref
+      end
+
+      # "6.0k in / 40 out": the row's prompt and completion sums.
+      def model_segment_tokens_text(row)
+        count = ->(key) { MemoryBundle::IndexSize.count_text(segment_value(row, key).to_i) }
+        "#{count.call(:prompt_sum)} in / #{count.call(:completion_sum)} out"
+      end
+
+      # "$0.42", "~$0.12", "$0.42 + ~$0.12" (reported + estimated); "" for none.
+      def model_segment_cost_text(row)
+        [cost_text(segment_value(row, :cost_sum)), cost_text(segment_value(row, :cost_estimate_sum), estimate: true)]
+          .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.
+      def model_segment_prefill_text(row)
+        tokens = segment_value(row, :prefill_tokens).to_i
+        return "" unless tokens.positive?
+
+        cost = cost_text(segment_value(row, :prefill_cost_estimate))
+        "switch prefill #{MemoryBundle::IndexSize.count_text(tokens)} uncached prompt#{" ≈#{cost}" unless cost.empty?}"
+      end
+
       private
 
       # The recap shown on return: dim, one "recap>" block, noting how many
@@ -574,12 +618,17 @@ module Samagotchi
           lines << "  called as:      #{aliased.map { |k, v| "#{k}=#{v}" }.join(", ")}"
         end
         lines << "iterations:       #{snapshot[:iterations_total]}"
-        # Summed over every request: each prompt is sent in full again.
-        lines << "tokens in/out:    #{tokens[:prompt_sum].to_i}/#{tokens[:completion_sum].to_i} (all requests, #{token_src_label})" \
-                 "#{token_breakdown_text(tokens)}"
-        speed = stats_speed_text(tokens)
+        segments = Array(snapshot[:model_segments])
+        if segments.size >= 2
+          lines.concat(models_block_lines(segments, snapshot[:turns], tokens, token_src_label))
+        else
+          # Summed over every request: each prompt is sent in full again.
+          lines << "tokens in/out:    #{tokens[:prompt_sum].to_i}/#{tokens[:completion_sum].to_i} (all requests, #{token_src_label})" \
+                   "#{token_breakdown_text(tokens)}"
+        end
+        speed = stats_speed_text(tokens, last_model: segments.size >= 2 ? last_speed_label(segments) : nil)
         lines << "speed:            #{speed}" if speed
-        cost = stats_cost_text(tokens, price_host: snapshot[:price_host])
+        cost = stats_cost_text(tokens, price_host: snapshot[:price_host], per_model: segments.size >= 2)
         lines << "cost:             #{cost}" if cost
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
@@ -682,19 +731,87 @@ module Samagotchi
 
       # "87 tok/s out, 1.9k tok/s prompt (last, server), avg 81 tok/s", or nil
       # before a generation had a speed. The prompt (prefill) speed only when
-      # the server reported it.
-      def stats_speed_text(tokens)
+      # the server reported it. +last_model+: the model the last speed came
+      # from, named when the session ran on several.
+      def stats_speed_text(tokens, last_model: nil)
         last = tokens[:last_decode_tps]
         return nil unless last
 
         source = tokens[:tps_source].to_s
         text = "#{speed_text(last, source)} out"
         text << ", #{speed_text(tokens[:last_prefill_tps], "server")} prompt" if tokens[:last_prefill_tps]
-        text << " (last, #{source})"
+        text << " (last, #{source}#{", #{last_model}" if last_model})"
         text << ", avg #{speed_text(tokens[:avg_decode_tps], source)}" if tokens[:avg_decode_tps]
         text
       end
 
+      def segment_value(row, key)
+        row[key] || row[key.to_s]
+      end
+
+      # /stats' models: block, in place of the tokens line: a row per
+      # segment (model, when, turns, tokens, its average speed and cost), a
+      # switch's prefill under the row of the model switched to, and the
+      # total (the tokens line's sums and breakdown).
+      def models_block_lines(segments, turns, tokens, token_src_label)
+        dated = segment_dates_differ?(segments)
+        cells = segments.map do |row|
+          speed = speed_text(segment_value(row, :avg_decode_tps), segment_value(row, :tps_source))
+          [model_segment_label(row), segment_span_text(row, dated: dated), turns_text(segment_value(row, :turns)),
+           [model_segment_tokens_text(row), speed, model_segment_cost_text(row)].reject(&:empty?).join("  ")]
+        end
+        total = ["total", "", turns_text(turns),
+                 "#{MemoryBundle::IndexSize.count_text(tokens[:prompt_sum].to_i)} in / " \
+                 "#{MemoryBundle::IndexSize.count_text(tokens[:completion_sum].to_i)} out " \
+                 "(all requests, #{token_src_label}#{token_breakdown_text(tokens)})"]
+        widths = (0..2).map { |i| (cells + [total]).map { |cell| cell[i].length }.max }
+        row_text = ->(cell) { cell.each_with_index.map { |text, i| i < 3 ? text.ljust(widths[i]) : text }.join("  ") }
+        lines = []
+        segments.each_with_index do |row, i|
+          lines << "#{i.zero? ? "models:".ljust(18) : " " * 18}#{row_text.call(cells[i])}"
+          prefill = model_segment_prefill_text(row)
+          lines << "#{" " * 20}└ #{prefill}" unless prefill.empty?
+        end
+        lines << "#{" " * 18}#{row_text.call(total)}"
+      end
+
+      def turns_text(count)
+        "#{count.to_i} #{count.to_i == 1 ? "turn" : "turns"}"
+      end
+
+      # "10:02–10:41", "10:43–now" (a row with a turn running); with the
+      # day ("Oct 16 10:02") when the rows span more than one day.
+      def segment_span_text(row, dated:)
+        started = segment_time(segment_value(row, :started_at))
+        ended = segment_time(segment_value(row, :ended_at))
+        format_time = lambda { |time|
+          if time
+            time.strftime(dated ? "%b %-d %H:%M" : "%H:%M")
+          else
+            "?"
+          end
+        }
+        "#{format_time.call(started)}–#{ended ? format_time.call(ended) : "now"}"
+      end
+
+      def segment_dates_differ?(segments)
+        days = segments.flat_map { |row| [segment_value(row, :started_at), segment_value(row, :ended_at)] }
+                       .filter_map { |stamp| segment_time(stamp)&.strftime("%F") }
+        days.uniq.size > 1
+      end
+
+      def segment_time(stamp)
+        stamp ? Time.iso8601(stamp.to_s).localtime : nil
+      rescue ArgumentError
+        nil
+      end
+
+      # The row the session's last speed came from: the newest with one.
+      def last_speed_label(segments)
+        row = segments.reverse_each.find { |segment| segment_value(segment, :last_decode_tps) }
+        row && model_segment_label(row)
+      end
+
       def format_elapsed_duration(duration_ms)
         duration_ms = duration_ms.to_f
         return "" if duration_ms.negative?

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -89,7 +89,9 @@ module Samagotchi
       # hint). Other events change nothing.
       def take_event(event)
         case event[:type]
-        when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
+        # usage nil (a /model whose window didn't resolve) clears it.
+        when :context_status
+          update(context: event[:usage] ? { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] } : nil)
         when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
         when :generation_completed
           update(served: [event[:served_model], event[:requested_model], event[:served_expected_by]]) if event[:served_model]

data/lib/samagotchi/toolkit.rb

@@ -77,16 +77,17 @@ module Samagotchi
         super
       end
 
-      # What the prompt carries of it: the declared names, the reachable
-      # and removed ones (the not-loaded line, find_tools' chi line), when
-      # either list has any the kit name the line gives, and the kit's
-      # prompt text. Two equal keys build the same prompt (/toolkit's "no
-      # change", its cost).
-      def prompt_key
-        [declared.map(&:name), reachable, removed, reachable.empty? && removed.empty? ? nil : resolved.name,
-         resolved.prompt]
+      # What the prompt carries before the kit's prompt text: the declared
+      # names, reachable and removed ones (the not-loaded line, find_tools'
+      # chi line), and, when either list has any, the kit name the line gives.
+      def tools_key
+        [declared.map(&:name), reachable, removed, reachable.empty? && removed.empty? ? nil : resolved.name]
       end
 
+      # What the prompt carries of it, including the kit's prompt text. Two
+      # equal keys build the same prompt (/toolkit's "no change", its cost).
+      def prompt_key = [*tools_key, resolved.prompt]
+
       # What the UIs show (the snapshot, command_ran): nil when it declares
       # every tool on full (full, full +delegate), which has no chip.
       # +left_out+ is +reachable+ and +removed+ together; +prompt+ (the

data/lib/samagotchi/toolkit_command.rb

@@ -129,9 +129,9 @@ module Samagotchi
 
     # What the confirm says is read again: from the tools on (the front of
     # every request), or from the kit's prompt text on when only that
-    # changes (Explained#prompt_key's last part: a kit on full's tools).
+    # changes (Explained#tools_key is unchanged: only a kit's prompt text).
     def reread_line(before, after)
-      if before.prompt_key[0...-1] == after.prompt_key[0...-1]
+      if before.tools_key == after.tools_key
         "The kit's prompt text is in the system prompt: the prompt is read again from it on."
       else
         "The tools are the front of every request: the whole prompt is read again from them on."

data/lib/samagotchi/tools/builtins.rb

@@ -144,11 +144,7 @@ module Samagotchi
 
       # The XDG dirs set in +env+, made absolute (nothing for an unset one).
       def xdg_absolute(env = ENV)
-        set = ->(key) { !env.fetch(key, "").to_s.strip.empty? }
-        dirs = {}
-        dirs["XDG_STATE_HOME"] = Paths.state_home(env: env) if set.call("XDG_STATE_HOME")
-        dirs["XDG_CONFIG_HOME"] = Paths.config_home(env: env) if set.call("XDG_CONFIG_HOME")
-        dirs
+        Paths.absolute_xdg(env: env)
       end
 
       # The unsets that keep a `chi --model X` worker's default from passing

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -1794,6 +1794,9 @@ module Samagotchi
           # before the next turn streams (live over saved).
           context: source["context"],
           tokens: source["tokens"],
+          # The tokens, cost and speeds per model (SessionMetrics'
+          # 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"]
         }

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

@@ -1475,7 +1475,7 @@ async function handleSendTurn({ delivery: chosen = null } = {}) {
     // The chips stay (uploaded ones keep their ref, to sentTo) for another try: an
     // image refused (bad_image, too_large, bad_images) says why below.
     if (e.code === "owned_by_tui") {
-      if (sentTo !== selected) return alert(e.message);
+      if (sentTo !== selected) return showToast(cantText(`send to ${sentTo.slice(0, 8)}`, e), null, { sticky: true });
       current.owner = "tui";
       updateComposerMode();
       return;
@@ -1485,7 +1485,7 @@ async function handleSendTurn({ delivery: chosen = null } = {}) {
     if (e.code === "not_found") return leaveGoneSession(sentTo, "not_found");
     // A /queue to a worker that can't queue (it would steer): its words, the text kept.
     if (e.code === "delivery_unavailable" && sentTo === selected) return addCommandBubble({ label: null, line, text: e.body?.detail || e.message, failed: true });
-    alert(e.message);
+    showToast(cantText("send", e), null, { sticky: true });
   } finally {
     actionBtn.disabled = current.owner === "tui";
     promptEl.focus();
@@ -1502,13 +1502,14 @@ const composerCommands = createComposerCommands({
   refreshHistory: () => refreshHistory(),
   failed: (line, text) => addCommandBubble({ label: null, line, text, failed: true }),
   // As handleSendTurn says a turn's failure after a switch.
-  failedElsewhere: (line, text) => alert(`${line}: ${text}`),
+  failedElsewhere: (line, text, id) => showToast(cantText(`run ${line} in ${id.slice(0, 8)}`, text), null, { sticky: true }),
   ownedByTui: () => {
     current.owner = "tui";
     updateComposerMode();
   },
   composer: {
     busy: () => { actionBtn.disabled = true; },
+    text: () => promptEl.value,
     clear: () => clearComposer(),
     done: () => {
       actionBtn.disabled = current.owner === "tui";

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

@@ -1,9 +1,9 @@
 // Session chains on the page (docs/sessions.md, Session chains): a session
-// that continues an earlier one (its summary's `continues`), "the next day of
+// that continues an earlier one (its summary's `continues`), "the next run of
 // the same routine". The chain is derived from the list, never stored: back
 // through `continues`, forward through the session whose `continues` names
 // this one. The lists fold a chain into its latest listed link's card (a
-// `day N` chip, its earlier links in a popover); the session page links the
+// `#N` chip, its earlier links in a popover); the session page links the
 // previous and the next link. Pure: lists_view.js places the chip and rows
 // (lit-html templates) and app.js the toast's markup, and they bind them.
 import { normalize, previewForCard, relativeTime } from "./format.js";
@@ -33,7 +33,7 @@ export function isOpener(text) {
 
 // A link's card title (format.js previewForCard), display only: a link
 // whose title is the opener, as every link's first message is once sent,
-// reads its chain's first link's title instead, so the days of a chain
+// reads its chain's first link's title instead, so the links of a chain
 // keep its name. Its own title when the first link isn't in +byId+ (id →
 // session; deleted, or a walk a missing link cut short) or is the opener too.
 export function chainTitle(s, byId) {
@@ -112,13 +112,32 @@ export function chainNeighbours(list, id, { continues = null } = {}) {
   return { prev, next };
 }
 
-// A link's day as the carry note writes it: the local YYYY-MM-DD of its
-// start; "" when it has none.
-export function chainDate(iso) {
+const pad = (n) => String(n).padStart(2, "0");
+const localDate = (iso) => {
   const d = new Date(iso || "");
-  if (Number.isNaN(d.getTime())) return "";
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+  return Number.isNaN(d.getTime()) ? null : d;
+};
+
+// A link's day as the carry note writes its date: the local YYYY-MM-DD of
+// its start; "" when it has none.
+export function chainDate(iso) {
+  const d = localDate(iso);
+  return d ? `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` : "";
+}
+
+// A link's start as a local HH:MM; "" when it has none.
+export function chainClock(iso) {
+  const d = localDate(iso);
+  return d ? `${pad(d.getHours())}:${pad(d.getMinutes())}` : "";
+}
+
+// A link's start as a chain list shows it: its date (chainDate), with its
+// HH:MM when one of +otherIsos+ (the chain's other links' starts) is on the
+// same local day, so two links of one day tell apart. "" when it has none.
+export function chainStamp(iso, otherIsos = []) {
+  const date = chainDate(iso);
+  if (!date) return "";
+  return otherIsos.some((o) => chainDate(o) === date) ? `${date} ${chainClock(iso)}` : date;
 }
 
 // The families (sessions_list.js families) with the chains folded in: a
@@ -129,7 +148,7 @@ export function chainDate(iso) {
 // index). +all+: every session the page holds, archived ones too (the links
 // the list leaves out). The same array when no chain is in it.
 // @param fold false: every family stays (each link's card carries its
-//   chip, "day 1 of 3"; folded false), for a search or the archived ones
+//   chip, "#1 of 3"; folded false), for a search or the archived ones
 export function foldChains(fams, all, { fold = true } = {}) {
   if (!all.some((s) => s.continues)) return fams;
   const nexts = nextsOf(all);
@@ -160,15 +179,15 @@ export function allViewChains(fams, all, { query = "", includeArchived = false }
 }
 
 // The links a family's chain list shows: the chain but its head, newest
-// first, each {session, day} (day: its 1-based place in the chain).
+// first, each {session, n} (n: its 1-based place in the chain).
 function chainOthers(f) {
   const links = f?.chain?.links || [];
-  return links.map((session, i) => ({ session, day: i + 1 }))
+  return links.map((session, i) => ({ session, n: i + 1 }))
     .filter(({ session }) => session.id !== f.head.id)
     .reverse();
 }
 
-// The chip in a chain's card: "day 3" (the head's place; "day 2 of 3" when
+// The chip in a chain's card: "#3" (the head's place; "#2 of 3" when
 // later links aren't listed), with a live dot / "waiting" when one of the
 // other links has a worker / waits on the user (typing in an archived link
 // brings it back, but it stays folded here). nothing for a family in no
@@ -180,12 +199,12 @@ export function chainChipTemplate(f, { open = false } = {}) {
   const others = chainOthers(f);
   const live = others.filter(({ session: s }) => s.owner === "worker").length;
   const waiting = others.filter(({ session: s }) => waitingOn(s)).length;
-  const day = at + 1;
-  const text = day === links.length ? `day ${day}` : `day ${day} of ${links.length}`;
+  const n = at + 1;
+  const text = n === links.length ? `#${n}` : `#${n} of ${links.length}`;
   const earlier = at;
   const later = links.length - 1 - at;
   const parts = [earlier ? `${earlier} earlier ${earlier === 1 ? "link" : "links"}` : "", later ? `${later} later` : ""].filter(Boolean);
-  const title = `Session chain: day ${day} of ${links.length} (${parts.join(", ")}); open the list`;
+  const title = `Session chain: link ${n} of ${links.length} (${parts.join(", ")}); open the list`;
   const liveT = live ? html`<span class="cc-live"> · <span class="live-dot" aria-hidden="true"></span>${live} live</span>` : nothing;
   const waitingT = waiting ? html` · <span class="cc-waiting">${waiting} waiting</span>` : nothing;
   return html`<button type="button" class=${`chain-chip${waiting ? " waiting" : ""}`} aria-expanded=${open ? "true" : "false"}
@@ -193,24 +212,26 @@ export function chainChipTemplate(f, { open = false } = {}) {
 }
 
 // The chain's list (the chip's popover): one row per other link, newest
-// first: status dot, "day N", its date, its recap's first sentence (else
+// first: status dot, "#N", its date (with its HH:MM when another link of
+// the chain, the head too, started the same day: chainStamp), its recap's first sentence (else
 // its preview), the waiting / stopped badge, archived. A row's click opens
 // that link (families_view.js's popover binds .family-row[data-id]).
 // @param activeId the open session's id (its row is .active)
 export function chainRowsTemplate(f, { activeId = null, now = Date.now() } = {}) {
   const byId = new Map((f?.chain?.links || []).map((s) => [s.id, s]));
-  const rows = chainOthers(f).map(({ session: s, day }) => {
+  const links = f?.chain?.links || [];
+  const rows = chainOthers(f).map(({ session: s, n }) => {
     const cls = ["family-row", "chain-row"];
     if (activeId && s.id === activeId) cls.push("active");
     if (s.archived) cls.push("archived");
     const waiting = waitingBadge(s, { inFamily: true });
     const stopped = waiting ? null : stoppedBadge(s);
-    const date = chainDate(s.created_at);
+    const date = chainStamp(s.created_at, links.filter((l) => l !== s).map((l) => l.created_at));
     const ago = relativeTime(s.updated_at || s.created_at || "", now);
     const tip = `${s.id} · ${s.status || ""}${ago ? ` · updated ${ago}` : ""}`;
     return html`<div class=${cls.join(" ")} data-id=${s.id} style=${"--depth:1"} role=${"listitem"}><button type="button" class="fr-open"
-      title=${tip}>${rowDotTemplate(s, waiting)}<span class="cr-day">day ${day}</span>${
-      date ? html`<span class="cr-date">${date}</span>` : nothing}<span class="fr-preview">${s.recap || chainTitle(s, byId)}</span>${
+      title=${tip}>${rowDotTemplate(s, waiting)}<span class="cr-n">#${n}</span>${
+      date ? html`<span class=${date.length > 10 ? "cr-date timed" : "cr-date"}>${date}</span>` : nothing}<span class="fr-preview">${s.recap || chainTitle(s, byId)}</span>${
       rowBadgesTemplate(waiting, stopped)}${s.archived ? archivedBadge : nothing}</button></div>`;
   });
   return html`<div class="family-rows chain-rows" role="list">${rows}</div>`;

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

@@ -60,9 +60,10 @@ export function routeSessionLine(prompt, { commands = [], images = 0, delivery =
 //   followWokenWorker()  the command woke the worker: follow its stream
 //   refreshHistory()
 //   failed(line, text)   a failed command's bubble
-//   failedElsewhere(line, text)   a command to a session no longer open failed
+//   failedElsewhere(line, text, id)   a command to session id, no longer open, failed
 //   ownedByTui()         a plain terminal holds the session
-//   composer: {busy(), clear(), done()}   the composer's send button and text
+//   composer: {busy(), text(), clear(), done()}   the composer's send button
+//                        and text (text(): what it holds now)
 export function createComposerCommands(deps) {
   const { session, clientId, sendCommand, followWokenWorker, refreshHistory, failed, failedElsewhere, ownedByTui,
           composer } = deps;
@@ -72,14 +73,17 @@ export function createComposerCommands(deps) {
   // worker, owner and history are left alone then.
   async function send(line) {
     const id = session();
+    // The composer is shared: a draft typed in a session opened meanwhile
+    // stays when the answer comes; only the text sent goes.
+    const sent = composer.text();
     composer.busy();
     try {
       await sendCommand(id, line, { clientId });
-      composer.clear();
+      if (composer.text() === sent) composer.clear();
       refreshHistory();
       if (session() === id) followWokenWorker();
     } catch (e) {
-      if (session() !== id) return failedElsewhere(line, e.message);
+      if (session() !== id) return failedElsewhere(line, e.message, id);
       if (e.code === "owned_by_tui") {
         ownedByTui();
         return;
@@ -103,7 +107,7 @@ export function createComposerCommands(deps) {
       return true;
     } catch (e) {
       if (session() === id) failed(line, e.message);
-      else failedElsewhere(line, e.message);
+      else failedElsewhere(line, e.message, id);
       return false;
     }
   }

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

@@ -133,14 +133,23 @@ export function ctxBarText(pct, windowSource = null) {
 }
 
 // The info bar's / the card's ctx tooltip: the window line under the title
-// when there's a number (tokensTipText), or why there's none — "No request
-// in this session yet" — when the page has no percent (before any request;
-// the page isn't told context.status is off, and the window always resolves,
-// so "?" never means 0).
-export function ctxBarTip(tokens, memoryIndex, window) {
-  if (num(window?.pct) === null) return "No request in this session yet";
+// when there's a number (tokensTipText), or why there's none when the page
+// has no percent: "No request in this session yet" before any request (the
+// page isn't told context.status is off, so "?" never means 0); after one,
+// "Context window unknown" over the session's tokens and per-model rows with
+// no window line (a window lookup that failed; a model list without a context
+// length still falls back to context.window_tokens or chi's default). +window.afterSwitch+ (the info
+// 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) {
+  if (num(window?.pct) === null) {
+    if (!num(tokens?.prompt_sum) && !num(tokens?.completion_sum)) return "No request in this session yet";
+    const why = window?.afterSwitch ? "Context window unknown until the next request" : "Context window unknown";
+    return tokensTipText(tokens, why, memoryIndex, null, segments);
+  }
 
-  return tokensTipText(tokens, undefined, memoryIndex, window);
+  return tokensTipText(tokens, undefined, memoryIndex, window, segments);
 }
 
 // The ctx tooltip's window line ({tokens:, source:, pct:, budget:} the
@@ -166,14 +175,67 @@ export function ctxWindowText(window) {
   return `context: ${used}${countK(tokens)} tokens${sourceText}`;
 }
 
+// ── A session's rows per model (the timing's modelSegments) ──────────────
+// The words /stats' models: block shares (Formatting#model_segment_*;
+// spec/shared/labels_matrix.json model_segments).
+
+// A row's model: its ref; the rows folded past the cap ("3 earlier
+// segments", told by folded_segments); a session's turns from before turns
+// named their model ("earlier turns").
+export function modelSegmentLabel(row) {
+  const folded = num(row?.folded_segments);
+  if (folded !== null && folded > 0) return `${folded} earlier segments`;
+  return row?.model_ref ? String(row.model_ref) : "earlier turns";
+}
+
+// "6.0k in / 40 out".
+export function modelSegmentTokensText(row) {
+  return `${countK(num(row?.prompt_sum) || 0)} in / ${countK(num(row?.completion_sum) || 0)} out`;
+}
+
+// "$0.42", "~$0.12", "$0.42 + ~$0.12"; "" for none.
+export function modelSegmentCostText(row) {
+  return [costText(row?.cost_sum), costText(row?.cost_estimate_sum, { estimate: true })].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.
+export function modelSegmentPrefillText(row) {
+  const tokens = num(row?.prefill_tokens) || 0;
+  if (tokens <= 0) return "";
+  const cost = costText(row?.prefill_cost_estimate);
+  return `switch prefill ${countK(tokens)} uncached prompt${cost ? ` ≈${cost}` : ""}`;
+}
+
+// The tooltip's rows per model, with ≥ 2 (one model: none): "model ·
+// turns · in / out · cost", a switch's prefill under its row.
+function modelSegmentLines(segments) {
+  if (!Array.isArray(segments) || segments.length < 2) return [];
+  const lines = ["per model:"];
+  for (const row of segments) {
+    const turns = num(row.turns) || 0;
+    const parts = [modelSegmentLabel(row), `${turns} ${turns === 1 ? "turn" : "turns"}`, modelSegmentTokensText(row)];
+    const cost = modelSegmentCostText(row);
+    if (cost) parts.push(cost);
+    lines.push(`  ${parts.join(" · ")}`);
+    const prefill = modelSegmentPrefillText(row);
+    if (prefill) lines.push(`    └ ${prefill}`);
+  }
+  return lines;
+}
+
 // The ctx tooltip (info bar and card): +title+, then the session's tokens
 // (in summed over every request, cached with its share, out with the
 // reasoning part) and its cost, when it has any (an estimated part with
 // "~", costLine), and the memory indexes
 // its prompt holds (+memoryIndex+, the snapshot's memory_index); with
-// +window+ (ctxWindowText's) the window line under the title. 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) {
+// +window+ (ctxWindowText's) the window line under the title; with
+// +segments+ (the timing's modelSegments, ≥ 2) the rows per model above the
+// 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) {
   const memory = memoryIndexText(memoryIndex);
   const memoryLine = memory ? `\nmemory index: ${memory}` : "";
   const windowText = ctxWindowText(window);
@@ -186,7 +248,7 @@ export function tokensTipText(tokens, title = "Context used after the last turn"
   const parts = [`in ${count(prompt)}`];
   if (cached > 0 && prompt > 0) parts.push(`cached ${count(cached)} (${Math.round((cached * 100) / prompt)}%)`);
   parts.push(`out ${count(completion)}${reasoning > 0 ? ` (reasoning ${count(reasoning)})` : ""}`);
-  const lines = [title, `tokens: ${parts.join(" · ")}`];
+  const lines = [title, ...modelSegmentLines(segments), `tokens: ${parts.join(" · ")}`];
   const cost = costLine(tokens);
   if (cost) lines.push(cost);
   lines.push("this session only, all requests");