samagotchi 0.19.0 → 0.21.0

data/lib/samagotchi/terminal_ui/reline_seam.rb

@@ -66,6 +66,12 @@ module Samagotchi
         # @api private
         attr_writer :reading
 
+        # Monotonic time a read's cursor query went out (#reset) when the read
+        # was stopped before Reline took the reply: the reply is still on its
+        # way, and LiveRegion.close waits for it. nil with none.
+        # @return [Float, nil]
+        attr_accessor :unanswered_query_at
+
         # @return [Boolean] this Reline has every method the seam relies on
         def supported?
           defined?(Reline::LineEditor::RenderedScreen) &&
@@ -107,7 +113,11 @@ module Samagotchi
       end
 
       def reset(...)
+        # Reline's reset asks the terminal for the cursor row and waits for
+        # the reply: a Stop raised meanwhile leaves this set.
+        RelineSeam.unanswered_query_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         super
+        RelineSeam.unanswered_query_at = nil
         RelineSeam.reading = true
         @rendered_screen.base_y = 0 if RelineSeam.screen
       end

data/lib/samagotchi/token_usage.rb

@@ -1,61 +1,58 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  # TokenUsage extracts real server-reported token counts from a model API
-  # stream payload, transport-agnostically.
+  # TokenUsage is the server-reported token accounting of one model API stream
+  # payload, read transport-agnostically.
   #
   # llama.cpp's /completion stream emits per-chunk `timings.prompt_n` /
   # `timings.predicted_n` (cumulative) and a final top-level
-  # `tokens_evaluated` / `tokens_predicted`. mlx_lm.server (OpenAI-compatible)
-  # emits a `usage` object with `prompt_tokens` / `completion_tokens`.
+  # `tokens_evaluated` / `tokens_predicted`. OpenAI-compatible servers emit a
+  # `usage` object with `prompt_tokens` / `completion_tokens`.
   #
-  # Returns nil when no server token data is present, so a caller can fall back
-  # to a chars/4 heuristic. The reported values are cumulative per request, so
-  # callers should take the running MAX across chunks (see SessionMetrics).
-  class TokenUsage
+  # The last chunk can say more: llama.cpp adds a `timings` block with exact
+  # speeds and `cache_n` (its native `tokens_cached` counts the new tokens too,
+  # so it is not read); OpenRouter adds `usage.cost` (USD) and the
+  # `prompt_tokens_details.cached_tokens` / `completion_tokens_details.reasoning_tokens`
+  # breakdowns. Those fields are nil when a payload doesn't carry them.
+  #
+  # from_payload returns nil when no server token counts are present, so a
+  # caller can fall back to a chars/4 heuristic. The reported values are
+  # cumulative per request, so callers should take the running MAX across
+  # chunks (see SessionMetrics).
+  class TokenUsage < Data.define(:prompt_tokens, :completion_tokens, :cached_tokens, :reasoning_tokens, :cost,
+                                 :predicted_per_second, :prompt_per_second, :predicted_ms, :source)
     CHARS_PER_TOKEN = 4.0
 
     class << self
       # @param payload [Hash, nil] the raw streamed chunk payload
-      # @return [Hash, nil] { prompt_tokens:, completion_tokens:, source: :server }
+      # @return [TokenUsage, nil]
       def from_payload(payload)
         payload_hash = payload.is_a?(Hash) ? payload : {}
-        usage = payload_hash["usage"] || payload_hash[:usage]
-        usage = {} unless usage.is_a?(Hash)
+        usage = hash_at(payload_hash, :usage)
+        timings = hash_at(payload_hash, :timings)
 
         prompt_tokens = first_positive(
-          usage["prompt_tokens"],
-          usage[:prompt_tokens],
-          payload_hash["prompt_tokens"],
-          payload_hash[:prompt_tokens],
-          payload_hash["prompt_n"],
-          payload_hash[:prompt_n],
-          payload_hash["tokens_evaluated"],
-          payload_hash[:tokens_evaluated],
-          payload_hash.dig("timings", "prompt_n"),
-          payload_hash.dig(:timings, :prompt_n)
+          *both(usage, :prompt_tokens), *both(payload_hash, :prompt_tokens), *both(payload_hash, :prompt_n),
+          *both(payload_hash, :tokens_evaluated), *both(timings, :prompt_n)
         )
-
         completion_tokens = first_positive(
-          usage["completion_tokens"],
-          usage[:completion_tokens],
-          payload_hash["completion_tokens"],
-          payload_hash[:completion_tokens],
-          payload_hash["predicted_n"],
-          payload_hash[:predicted_n],
-          payload_hash["tokens_predicted"],
-          payload_hash[:tokens_predicted],
-          payload_hash.dig("timings", "predicted_n"),
-          payload_hash.dig(:timings, :predicted_n)
+          *both(usage, :completion_tokens), *both(payload_hash, :completion_tokens),
+          *both(payload_hash, :predicted_n), *both(payload_hash, :tokens_predicted), *both(timings, :predicted_n)
         )
-
         return nil unless prompt_tokens || completion_tokens
 
-        {
+        new(
           prompt_tokens: prompt_tokens,
           completion_tokens: completion_tokens,
+          cached_tokens: first_positive(*both(hash_at(usage, :prompt_tokens_details), :cached_tokens),
+                                        *both(timings, :cache_n)),
+          reasoning_tokens: first_positive(*both(hash_at(usage, :completion_tokens_details), :reasoning_tokens)),
+          cost: number(*both(usage, :cost)),
+          predicted_per_second: positive_number(*both(timings, :predicted_per_second)),
+          prompt_per_second: positive_number(*both(timings, :prompt_per_second)),
+          predicted_ms: positive_number(*both(timings, :predicted_ms)),
           source: :server
-        }
+        )
       end
 
       # Estimate token count from raw text length using the chars/4 heuristic.
@@ -73,16 +70,35 @@ module Samagotchi
       # float never raises RangeError; non-numeric values are skipped.
       def first_positive(*values)
         values.each do |value|
-          next if value.nil?
-
-          n = Float(value).to_i
-          return n if n.positive?
-        rescue ArgumentError, TypeError
-          next
+          n = float(value)&.to_i
+          return n if n&.positive?
         end
 
         nil
       end
+
+      private
+
+      def hash_at(hash, key)
+        value = hash[key.to_s] || hash[key]
+        value.is_a?(Hash) ? value : {}
+      end
+
+      def both(hash, key) = [hash[key.to_s], hash[key]]
+
+      def positive_number(*values) = values.filter_map { |value| float(value) }.find(&:positive?)
+
+      # A cost of 0 is a real answer (a free model), so zero counts here.
+      def number(*values) = values.filter_map { |value| float(value) }.find { |n| n >= 0 }
+
+      def float(value)
+        return nil if value.nil?
+
+        n = Float(value)
+        n.finite? ? n : nil
+      rescue ArgumentError, TypeError
+        nil
+      end
     end
   end
 end

data/lib/samagotchi/tool_runner.rb

@@ -44,6 +44,7 @@ module Samagotchi
     def run(call, iteration:, call_index:, call_count:, on_stream_event:, max_tool_output_chars:)
       params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
       # The gate runs first, so tool_call_started shows the call that runs.
+      original = call.dup
       verdict = evaluate(call, iteration, params)
       call = verdict.call
       params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
@@ -73,6 +74,11 @@ module Samagotchi
       result, images = attach_images(call, result) if result[:images]
 
       output = scrub(result[:output].to_s)
+      # The gate may have replaced the call (known-names corrects a near
+      # miss): one leading line tells the model what actually ran.
+      if (changed = changed_call_line(original, call))
+        output = "#{changed}\n#{output}"
+      end
       capped = output
       truncated = false
       if max_tool_output_chars && output.length > max_tool_output_chars
@@ -84,14 +90,16 @@ module Samagotchi
       # full output: ok, error, blocked, stopped); a dispatcher that raised
       # left none, an error.
       status = result[:activity].is_a?(Hash) ? result[:activity][:status] : nil
-      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
-                               status: status || "error" })
       completed = { type: :tool_call_completed, iteration: iteration, call_count: call_count, call_index: call_index,
                     tool: call[:name], output: capped, output_truncated: truncated, activity: result[:activity] }
       completed[:images] = images if images&.any?
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
       emit(on_stream_event, completed)
+      # After the completed event: a hook's card (check-in, skills) prints
+      # under the call's tool row, not before it.
+      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
+                               status: status || "error" })
 
       run = { output: output, capped_output: capped, truncated: truncated, activity: result[:activity] }
       run[:images] = images if images&.any?
@@ -203,6 +211,17 @@ module Samagotchi
     # A plugin tool's label, what the UIs show for its raw name.
     def plugin_label(name) = ToolActivity.plugin_label(name, registry: tools)
 
+    # The one leading line the model gets when the gate changed the call it
+    # asked for: "ran as: <tool> <changed args>", or nil when nothing
+    # changed. The args are the changed call's activity params, so the line
+    # stays short.
+    def changed_call_line(original, call)
+      return nil if original == call
+
+      params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
+      ["ran as: #{call[:name]}", params].compact.join(" ")
+    end
+
     # The Engine sets the kernel's gate (its context, later the approval
     # flow); a bare kernel (specs) gets one that only runs the hooks.
     def gate

data/lib/samagotchi/tools/execute.rb

@@ -199,22 +199,23 @@ module Samagotchi
         # thread; the text is safe to read afterwards.
         def finish
           @thread.join(STOP_POLL_INTERVAL_SEC) unless done?
-          Execute.send(:close_quietly, @io)
+          close_quietly
           @thread.kill unless @thread.join(STOP_GRACE_SEC)
         end
 
         def text
           @buffer.dup.force_encoding(@io.external_encoding || Encoding.default_external)
         end
-      end
-      private_constant :OutputReader
 
-      def self.close_quietly(io)
-        io.close unless io.closed?
-      rescue IOError
-        nil
+        private
+
+        def close_quietly
+          @io.close unless @io.closed?
+        rescue IOError
+          nil
+        end
       end
-      private_class_method :close_quietly
+      private_constant :OutputReader
 
       def self.terminate_process_tree(pid)
         signal_process(pid, "TERM")

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -21,6 +21,7 @@ require_relative "../steer"
 require_relative "../host_registry"
 require_relative "../model_catalog"
 require_relative "../model_profile"
+require_relative "../sampling_settings"
 require_relative "../project_scope"
 require_relative "../prompt_history"
 require_relative "../version"
@@ -440,11 +441,29 @@ module Samagotchi
         if default && models.none? { |m| m[:name].casecmp?(default) }
           models.unshift({ name: default, host: nil, id: default })
         end
+        add_sampling(models, registry)
         payload = { default: default, models: models }
         payload[:warning] = warnings.join("; ") unless warnings.empty?
         json_response(200, payload)
       end
 
+      # Each model's configured sampling as /model words it ("temperature=0.6
+      # (hosts.work)"), on the models that have some: the picker's tooltip.
+      # A config that can't be read leaves the list as it is.
+      def add_sampling(models, registry)
+        return if registry.nil? || models.empty?
+
+        settings = ConfigFile.model_settings
+        models.each do |model|
+          target = registry.resolve(model[:name])
+          summary = SamplingSettings.summary(target, names: registry.lookup_names(model[:name], target: target),
+                                                     models: settings)
+          model[:sampling] = summary if summary
+        end
+      rescue StandardError
+        nil
+      end
+
       # Built again when config.yml's hosts: changed (compared as read: the
       # YAML read is mtime-cached), so the model picker lists a host added
       # while chi web runs. An injected registry (specs) stays.

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

@@ -20,7 +20,7 @@ import { MODEL_KEY } from "./model_pick.js";
 import { emptySessionState } from "./session_state.js";
 import { createModelPicker } from "./model_picker.js";
 import { chipName, chipsHtml, imageFiles, restoredChips, thumbsHtml, turnRefs, turnText } from "./images.js";
-import { escapeHtml, noteHtml, normalize, steerRowHtml, userBodyHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy } from "./format.js";
+import { escapeHtml, memChipText, memChipTitle, noteHtml, normalize, steerRowHtml, userBodyHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy } from "./format.js";
 import { EMPTY_ANSWER_CLASS, createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { createStageView } from "./stage_view.js";
 import { appendQuote } from "./annotations.js";
@@ -28,9 +28,9 @@ import { parsePresets } from "./annotate_presets.js";
 import { createAnnotateBar } from "./annotate_bar.js";
 import { COPY_SOURCE_ATTR, copySource, copyText, installCopy, showsAnswer } from "./copy.js";
 import { routeChunk } from "./chunk_router.js";
-import { extractCtxPct, savedCtxPct, cardCtxText } from "./ctx.js";
+import { extractCtxPct, savedCtxPct, cardCtxText, generationTokens, lastSpeedText, speedText, tokensTipText } from "./ctx.js";
 import { createQuestionCards } from "./question_cards.js";
-import { cardClass, cardInnerHtml, cardPlace, isCard, splitSnapshotCards, turnNoticePlace } from "./card.js";
+import { cardClass, cardInnerHtml, cardPlace, isCard, isNoticeCard, noticeInnerHtml, splitSnapshotCards, turnNoticePlace } from "./card.js";
 import { gripFloor, promptHeight } from "./composer_size.js";
 import { createCommandList } from "./command_list.js";
 import { createPromptHistory } from "./prompt_history.js";
@@ -45,7 +45,7 @@ import {
   appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, mergeTiming, normalizeTiming, turnTimingText,
 } from "./timing.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, displayWait, dropEarlyRestores, emptyAnswerLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, retryStatusLine, snapshotEvents, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, displayWait, dropEarlyRestores, emptyAnswerLine, emptyRetryLine, hookNoticeLabel, initWaitLine, isOwn, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -134,6 +134,9 @@ const questionCards = createQuestionCards({
 // was rendered at (null: no live worker then), where a stream opened later
 // has to start.
 let selectSeq = null;
+// The stream was opened from 0 (a wake with no cursor to go on) and no
+// new turn has started on it yet: see followWokenWorker.
+let streamFromGuess = false;
 // The last input_merged had an origin with no bubble: its merged text
 // (pending_input_merged) gets one.
 let unmatchedMerge = false;
@@ -165,6 +168,7 @@ let scopeError = null;
 async function refresh() {
   try {
     allSessions = await listSessions("updated_at", "desc", { dir: scope.dir });
+    notifications.noticeList(allSessions);
   } catch (e) {
     if (e.status !== 400 || !scope.dir) throw e;
     scopeError = e.message;
@@ -317,7 +321,7 @@ function cardHtml(s, { deletable = false } = {}) {
   const folderHtml = folder ? `<span class="folder" title="${escapeHtml(s.working_directory)}">${escapeHtml(folder)}</span>` : "";
   const archivedHtml = s.archived ? `<span class="archived-badge" title="Archived: hidden from the lists, kept for good">archived</span>` : "";
   const ctx = cardCtxText(s.ctx_pct);
-  const ctxHtml = ctx ? `<span class="ctx" title="Context used after the last turn">${escapeHtml(ctx)}</span>` : "";
+  const ctxHtml = ctx ? `<span class="ctx" title="${escapeHtml(tokensTipText(s.tokens))}">${escapeHtml(ctx)}</span>` : "";
   const waiting = waitingBadge(s);
   const waitingHtml = waiting ? `<span class="attn attn-${waiting.kind}" title="${escapeHtml(waiting.title)}">${escapeHtml(waiting.text)}</span>` : "";
   const dotWord = waiting ? waiting.title : s.status;
@@ -1173,13 +1177,26 @@ function cardElement(id) {
   return findInTurnRoots(".plugin-card").find((el) => el.dataset.cardId === String(id)) || null;
 }
 
+// A notice is a <details> (a one-line row that opens), a card a <div>: a
+// card that turns into the other kind (btw's "thinking…" → its answer) is
+// drawn on a new element in its place. Returns the element drawn.
 function drawCard(el, card) {
+  const notice = isNoticeCard(card);
+  if (el.tagName !== (notice ? "DETAILS" : "DIV")) {
+    const fresh = document.createElement(notice ? "details" : "div");
+    el.replaceWith(fresh);
+    el = fresh;
+  }
   el.className = cardClass(card);
   el.dataset.cardId = card.id;
   // A running turn's own card (the stage's status waits on one that asks).
   if (card.in_turn) el.dataset.inTurn = "1";
   else delete el.dataset.inTurn;
-  if (card.body_html === undefined && el.dataset.body === String(card.body ?? "") && el.querySelector(".card-body")) {
+  if (notice) {
+    const open = el.open;
+    el.innerHTML = noticeInnerHtml(card);
+    el.open = open;
+  } else if (card.body_html === undefined && el.dataset.body === String(card.body ?? "") && el.querySelector(".card-body")) {
     // The same body again from the stream: keep the rendered one.
     const body = el.querySelector(".card-body").innerHTML;
     el.innerHTML = cardInnerHtml({ ...card, body_html: body });
@@ -1187,6 +1204,7 @@ function drawCard(el, card) {
     el.innerHTML = cardInnerHtml(card);
   }
   el.dataset.body = String(card.body ?? "");
+  return el;
 }
 
 // Show +card+: update the one with its id where it is, else add it (a
@@ -1198,14 +1216,13 @@ function upsertCard(card, { before = null } = {}) {
   if (!card || !card.id) return;
   const existing = cardElement(card.id);
   if (existing) {
-    drawCard(existing, card);
-    existing.classList.add("card-updated");
-    setTimeout(() => existing.classList.remove("card-updated"), 900);
+    const drawn = drawCard(existing, card);
+    drawn.classList.add("card-updated");
+    setTimeout(() => drawn.classList.remove("card-updated"), 900);
     return;
   }
   removeHintIfEmpty();
-  const el = document.createElement("div");
-  drawCard(el, card);
+  const el = drawCard(document.createElement(isNoticeCard(card) ? "details" : "div"), card);
   const asks = (card.actions || []).some((a) => a && a.command);
   if (card.in_turn && !before && !asks && turnDom.card(el)) return;
   const follow = isNearBottom();
@@ -1328,7 +1345,7 @@ function onCardAction(e) {
   sendCommand(selected, button.dataset.command, { clientId, card: true })
     .then(() => {
       // The command woke the worker: follow its stream if none is open.
-      if (!streamControl?.live) startStream(selected, selectSeq ?? 0);
+      followWokenWorker();
     })
     .catch((error) => {
       err.textContent = error.message;
@@ -1403,6 +1420,7 @@ function updateInfoBar() {
     archiveBtn.style.display = selected ? "" : "none";
     const archived = selectedArchived();
     archiveBtn.textContent = archived ? "unarchive" : "archive";
+    archiveBtn.classList.toggle("archived", archived);
     archiveBtn.title = archived ? "Unarchive: back to the lists" : "Archive: hide from the lists, keep for good";
   }
   if (!selected) {
@@ -1416,6 +1434,11 @@ function updateInfoBar() {
   const idShort = selected.slice(0,8);
   const memText = current.usedMemories.length ? current.usedMemories.join(", ") : "—";
   const ctxText = current.ctxPct !== null ? `ctx ${Math.round(current.ctxPct)}%` : "";
+  const tokens = current.timing.tokens;
+  const ctxTip = tokensTipText(tokens);
+  const speedTextNow = lastSpeedText(tokens);
+  const avgSpeed = speedText(tokens?.avg_decode_tps, tokens?.tps_source);
+  const speedTip = `Decode speed of the last generation${avgSpeed ? `; session average ${avgSpeed}` : ""}`;
   const sessionDuration = currentSessionDuration();
   const timingText = sessionDuration === null ? "" : `session ${formatDuration(sessionDuration)}`;
   const statusClass = current.status ? `status ${escapeHtml(current.status)}` : "status";
@@ -1426,7 +1449,7 @@ function updateInfoBar() {
   const attachCmd = `chi --attach ${selected}`;
   const copied = Date.now() - attachCopiedAt < 2000;
   const copyHtml = `<button type="button" class="copy-attach" title="Copy &quot;${escapeHtml(attachCmd)}&quot; to attach a terminal">${copied ? "copied ✓" : "copy chi --attach"}</button>`;
-  const metaHtml = `<div class="meta"><span class="id" title="${escapeHtml(selected)}">${escapeHtml(idShort)}</span>${copyHtml}<span class="${statusClass}">${escapeHtml(current.status||"")}</span><span class="model${label.mismatch ? " served-mismatch" : ""}" title="${escapeHtml(label.title)}">${escapeHtml(label.text)}</span>${parentHtml}<span class="dir" title="${escapeHtml(current.dir||"")}">${escapeHtml((current.dir||"").slice(0,48))}</span>${ctxText ? `<span class="model">${escapeHtml(ctxText)}</span>` : ""}${timingText ? `<span class="model">${escapeHtml(timingText)}</span>` : ""}${workerBadgeHtml()}</div>`;
+  const metaHtml = `<div class="meta"><span class="id" title="${escapeHtml(selected)}">${escapeHtml(idShort)}</span>${copyHtml}<span class="${statusClass}">${escapeHtml(current.status||"")}</span><span class="model${label.mismatch ? " served-mismatch" : ""}" title="${escapeHtml(label.title)}">${escapeHtml(label.text)}</span>${parentHtml}${current.usedMemories.length ? `<span class="model mem-chip" title="${escapeHtml(memChipTitle(current.usedMemories))}">${escapeHtml(memChipText(current.usedMemories))}</span>` : ""}<span class="dir" title="${escapeHtml(current.dir||"")}">${escapeHtml((current.dir||"").slice(0,48))}</span>${ctxText ? `<span class="model ctx" title="${escapeHtml(ctxTip)}">${escapeHtml(ctxText)}</span>` : ""}${speedTextNow ? `<span class="model speed" title="${escapeHtml(speedTip)}">${escapeHtml(speedTextNow)}</span>` : ""}${timingText ? `<span class="model">${escapeHtml(timingText)}</span>` : ""}${workerBadgeHtml()}</div>`;
   const previewHtml = `<div class="preview-line"><span class="preview">${escapeHtml(current.firstPreview || "—")}</span> · <span class="mem" title="${escapeHtml(current.usedMemories.join(", "))}">mem: ${escapeHtml(memText)}</span></div>`;
   infoTextEl.innerHTML = metaHtml + previewHtml;
   infoTextEl.title = memoriesTooltip(current.usedMemories, current.preloadedMemories, current.mutedMemories);
@@ -1575,7 +1598,18 @@ function setUsedMemories(names) {
   }
 }
 
+// A turn or command just woke the session's worker: follow its stream if
+// none is open, from the render's cursor. A render with none (no worker
+// then) streams from 0, the start of a new worker's events; should that
+// worker have been up already, turn_started says so (replaysDrawnTurn).
+function followWokenWorker() {
+  if (streamControl?.live) return;
+  startStream(selected, selectSeq ?? 0);
+  streamFromGuess = selectSeq === null;
+}
+
 function startStream(id, fromSeq) {
+  streamFromGuess = false;
   if (streamControl) {
     streamControl.close();
     streamControl = null;
@@ -1648,16 +1682,17 @@ const streamHandlers = {
   },
   generation_completed: (data) => {
     setLiveTurnNote("");
-    if (data?.served_model) {
-      current.served = [data.served_model, data.requested_model];
-      updateInfoBar();
-    }
+    if (data?.served_model) current.served = [data.served_model, data.requested_model];
+    // 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();
     turnDom.generationCompleted();
   },
   // Prompts sent while a turn ran merge into it at an iteration boundary:
   // input_merged names them (their bubbles turn "steered"), then
   // pending_input_merged carries the merged text, shown only for prompts
-  // this tab has no bubble for.
+  // this tab has no bubble for. Its `answer` (the answer the merge
+  // superseded) is the TUI's line: here it streamed as that step's text.
   input_merged: (data) => applyPromptOps(data),
   pending_input_merged: (data) => {
     applyPromptOps(data);
@@ -1665,6 +1700,16 @@ const streamHandlers = {
   },
   turn_enqueued: (data) => applyPromptOps(data),
   turn_started: (data) => keepFollowing(historyEl, () => {
+    if (streamFromGuess) {
+      streamFromGuess = false;
+      // A replay of a turn the render drew: re-read and stream from there.
+      if (replaysDrawnTurn(data, current.timing.turnRecords)) {
+        streamControl?.close();
+        streamControl = null;
+        resync();
+        return;
+      }
+    }
     // A finished turn still in the stage goes first: the start op looks
     // for a queued prompt among its rows.
     turnDom.handOff?.({ immediate: true });
@@ -1711,7 +1756,7 @@ const streamHandlers = {
     }
   },
   turn_canceled: (data) => {
-    endTurnView("canceled", cancelLineText(data.cancellation_reason || ""));
+    endTurnView("canceled", cancelLineText(data.cancellation_reason || "", data.cancelled_by));
     setLiveStatus("idle");
     refreshTimingFromSession();
   },
@@ -1947,7 +1992,7 @@ async function handleSendTurn() {
       echo.remove();
       promptEl.value = "";
       fitPrompt();
-      if (!streamControl?.live) startStream(selected, selectSeq ?? 0);
+      followWokenWorker();
       return;
     }
     if (ack?.enqueued_id) sentIds.add(ack.enqueued_id);
@@ -1969,7 +2014,7 @@ async function handleSendTurn() {
     // events in between. Without one, POST /turn just woke a worker: its
     // events start after the seq the session was rendered at (0 for a new
     // worker process).
-    if (!streamControl?.live) startStream(selected, selectSeq ?? 0);
+    followWokenWorker();
   } catch (e) {
     echo.remove();
     // The turn never reached the worker's queue: an early restore waiting
@@ -2010,7 +2055,7 @@ async function handleSendCommand(line) {
     fitPrompt();
     refreshHistory();
     // The command woke the worker: follow its stream if none is open.
-    if (!streamControl?.live) startStream(selected, selectSeq ?? 0);
+    followWokenWorker();
   } catch (e) {
     if (/owned_by_tui|409/.test(e.message)) {
       current.owner = "tui";
@@ -2432,6 +2477,7 @@ shortWindow.addEventListener("change", () => {
   applyStripHidden();
 });
 $("#stripShow").addEventListener("click", () => setStripHidden(false));
+$("#stripHideTop").addEventListener("click", () => setStripHidden(true));
 
 $("#filter").addEventListener("input", renderAll);
 // A list whose order was held under the pointer (listOrder) catches up.

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

@@ -3,9 +3,41 @@
 // the element; this module draws it and says where it goes.
 import { escapeHtml, recapPlace } from "./format.js";
 
-// The card's class: a warn card wears the warning colour.
+// The card's class: a warn card wears the warning colour; a notice is a
+// one-line row.
 export function cardClass(card) {
-  return "bubble plugin-card" + (card?.level === "warn" ? " warn" : "");
+  return "bubble plugin-card" + (card?.level === "warn" ? " warn" : "") + (isNoticeCard(card) ? " notice" : "");
+}
+
+// The longest body a notice row carries; a longer one is a card to read.
+export const NOTICE_CHARS = 160;
+
+// Whether a card is a notice (check-in's "Nudged the model at 105 tool
+// calls."): info level, nothing to click, a body of one short line. It
+// shows as a collapsed one-line row, "▸ check-in: Nudged …", as the tool
+// rows and the resolved question cards do; a click opens it. A warn card,
+// one that asks (actions) and one with more to read stay cards.
+export function isNoticeCard(card) {
+  if (!card || card.level === "warn") return false;
+  if ((card.actions || []).some((a) => a && a.command)) return false;
+  const body = String(card.body ?? "").trim();
+  return !body.includes("\n") && body.length <= NOTICE_CHARS;
+}
+
+// A notice's one line: "title: body" (the title alone for no body).
+export function noticeCardLine(card) {
+  const title = String(card?.title ?? "").trim();
+  const body = String(card?.body ?? "").trim();
+  return title && body ? `${title}: ${body}` : title || body;
+}
+
+// A notice's markup inside its <details>: the line as the summary, and
+// where it came from when the row is opened (the line wraps then).
+export function noticeInnerHtml(card) {
+  const title = String(card?.title ?? "").trim();
+  const source = String(card?.source ?? "").trim();
+  const from = source && source !== title ? `<div class="notice-from">from <span class="card-source">${escapeHtml(source)}</span></div>` : "";
+  return `<summary>${escapeHtml(noticeCardLine(card))}</summary>${from}`;
 }
 
 // Whether a card shown as a row of a step leaves the turn's block when the

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

@@ -48,3 +48,62 @@ export function savedCtxPct(context) {
 export function cardCtxText(pct) {
   return num(pct) === null ? "" : `${Math.round(pct)}%`;
 }
+
+// A decode speed: "87 tok/s", "1.9k tok/s"; "~64 tok/s" for an estimate (no
+// server timings); "" without one. The TUI's /stats says the same
+// (Formatting#speed_text; spec/shared/labels_matrix.json).
+export function speedText(tps, source) {
+  const value = num(tps);
+  if (value === null || value <= 0) return "";
+  const number = value >= 1000 ? `${(Math.round(value / 100) / 10).toFixed(1)}k` : String(Math.round(value));
+  return `${source === "estimate" ? "~" : ""}${number} tok/s`;
+}
+
+// A cost in USD: "$0.42"; under a cent, four decimals ("$0.0012"); "" for
+// none or zero. As Formatting#cost_text.
+export function costText(cost) {
+  const value = num(cost);
+  if (value === null || value <= 0) return "";
+  return value >= 0.01 ? `$${value.toFixed(2)}` : `$${value.toFixed(4)}`;
+}
+
+function count(n) {
+  return Math.round(n).toLocaleString("en-US");
+}
+
+// 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. 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") {
+  const prompt = num(tokens?.prompt_sum) || 0;
+  const completion = num(tokens?.completion_sum) || 0;
+  if (!prompt && !completion) return title;
+  const cached = num(tokens.cached_sum) || 0;
+  const reasoning = num(tokens.reasoning_sum) || 0;
+  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 cost = costText(tokens.cost_sum);
+  if (cost) lines.push(`cost: ${cost}`);
+  lines.push("this session only, all requests");
+  return lines.join("\n");
+}
+
+// The info bar's speed: the newest generation's decode speed, "" before one.
+export function lastSpeedText(tokens) {
+  return speedText(tokens?.last_decode_tps, tokens?.tps_source);
+}
+
+// The session's tokens block after a :generation_completed: the event's
+// running totals (the server closed the generation and put them on it),
+// with its speed; an event without them (a replay, an older worker) keeps
+// +previous+.
+export function generationTokens(previous, data) {
+  const tokens = data?.tokens;
+  if (!tokens || typeof tokens !== "object") return previous ?? null;
+  const speed = data.speed;
+  if (!speed || num(speed.decode_tps) === null) return tokens;
+  return { ...tokens, last_decode_tps: speed.decode_tps, tps_source: speed.source };
+}