samagotchi 0.40.0 → 0.42.0

data/lib/samagotchi/turn_flow.rb

@@ -3,6 +3,7 @@
 require_relative "output_formatter"
 require_relative "turn_note"
 require_relative "context_note"
+require_relative "llm/errors"
 
 module Samagotchi
   # The state around turns that the REPL and a session worker share, kept out
@@ -45,11 +46,18 @@ module Samagotchi
     #   (context summarizes the interrupted turn for a "no, <reason>")
     attr_reader :offer
 
+    # How many times the conversation went back to a checkpoint (a failed
+    # or canceled turn's restore, !rollback): a worker compares it across a
+    # turn to tell whether the turn's messages (the delegate reports it
+    # merged) left the conversation.
+    attr_reader :restores
+
     def initialize(engine:)
       @engine = engine
       @checkpoint = nil
       @continue_checkpoint = nil
       @offer = nil
+      @restores = 0
     end
 
     def awaiting_continue? = !@offer.nil?
@@ -95,17 +103,44 @@ module Samagotchi
       end
     end
 
-    # A prompt turn failed: back to the conversation before it, plus the
-    # note that says so (TurnNote.failed) in place of an older one at the
-    # tail, so the model reads why its last message went unanswered.
-    def prompt_turn_failed(note: nil)
+    # A prompt turn (or a wake turn) failed. One that got somewhere (the
+    # Engine kept its tool results: LLM::FailedTurn.kept_steps, never for
+    # a context overflow) stays, as after a cancel: its tool calls ran, and
+    # the model must see what they did. The checkpoint stays for !rollback, and
+    # the prompt is answered by what the turn did, so it doesn't go back to
+    # its sender. One that got nowhere goes back to the conversation before
+    # it, and its prompt to its sender (the caller hands it back).
+    # Either way the note at the tail says why (TurnNote.failed), in place
+    # of an older one, so the model reads why its last message went
+    # unanswered.
+    # @param error [Exception, nil] what failed: its one line is the note's
+    # @param wake [String, nil] what woke the turn (TurnNote.failed's wake:)
+    # @param wake_kept [String, nil] what becomes of the wake's news when
+    #   the turn is rolled back (TurnNote.failed's kept:)
+    # @param note [Boolean] false: no note (an image that never reached the
+    #   model)
+    # @return [Symbol] :kept or :restored
+    def prompt_turn_failed(error: nil, wake: nil, wake_kept: nil, note: true)
+      summary = error && (error.respond_to?(:summary) ? error.summary : error.message)
+      steps = LLM::FailedTurn.kept_steps(error)
+      @offer = nil
+      if steps
+        # The Engine's note says so already; a wake turn's says what woke it.
+        if wake && note
+          @engine.rollback_to(TurnNote.replace_trailing(@engine.messages_checkpoint,
+                                                        TurnNote.failed(summary, wake: wake, steps: steps)))
+        end
+        return :kept
+      end
+
+      failed = note && summary && TurnNote.failed(summary, restored: wake.nil?, wake: wake, kept: wake_kept)
       if @checkpoint
-        restore(@checkpoint, note: note)
-      elsif note
-        @engine.rollback_to(TurnNote.replace_trailing(@engine.messages_checkpoint, note))
+        restore(@checkpoint, note: failed)
+      elsif failed
+        @engine.rollback_to(TurnNote.replace_trailing(@engine.messages_checkpoint, failed))
       end
-      @offer = nil
       @checkpoint = nil
+      :restored
     end
 
     # Answer the offer with no (Stop): the interrupted turn stays, as
@@ -170,6 +205,7 @@ module Samagotchi
       restored = Array(checkpoint) + arrived
       restored = TurnNote.replace_trailing(restored, note) if note
       @engine.rollback_to(restored)
+      @restores += 1
     end
 
     def conversation_of(result)

data/lib/samagotchi/turn_note.rb

@@ -17,6 +17,10 @@ module Samagotchi
     OPEN = "[SYSTEM: "
     CLOSE = "]"
     FAILED = "the previous turn failed before any answer: "
+    # A failed turn whose work stayed (#failed_after): "failed after N tool
+    # steps: <why>. Its work so far … stays; …".
+    FAILED_AFTER = "the previous turn failed after "
+    KEPT_WORK = ". Its work so far (tool calls, file changes) stays; "
     RESTORED = "The message went back to the user, who may send it again."
     TASKS_LISTED = 5
     TASK_COMMAND_CHARS = 60
@@ -41,7 +45,12 @@ module Samagotchi
     #   wrote nothing, and wakes pause until they do
     # @param kept [String, nil] what becomes of the wake's news, after
     #   that (a delegate report's rings stay for the user's next turn)
-    def failed(summary, restored: false, continued: false, wake: nil, kept: nil)
+    # @param steps [Integer, nil] the turn's work stays in the conversation
+    #   (LLM::FailedTurn.progress): the tool results it got to. Not with
+    #   +restored+, which took the turn out.
+    def failed(summary, restored: false, continued: false, wake: nil, kept: nil, steps: nil)
+      return failed_after(summary, steps, continued: continued, wake: wake) if steps && !restored
+
       tail = if restored then RESTORED
              elsif wake
                "The wake turn for #{one_line(wake)} was not answered; chi starts no other wake turn until the user writes." +
@@ -52,6 +61,36 @@ module Samagotchi
       message("#{FAILED}#{one_line(summary)}. #{tail}")
     end
 
+    # A turn that failed partway, its work kept: "the previous turn failed
+    # after 3 tool steps: <why>. Its work so far (tool calls, file changes)
+    # stays; …".
+    def failed_after(summary, steps, continued: false, wake: nil)
+      count = "#{steps} tool step#{"s" if steps != 1}"
+      tail = if wake
+               "the wake turn for #{one_line(wake)} stopped there; chi starts no other wake turn until the user writes."
+             elsif continued then "the continued turn stopped there."
+             else
+               "the user's last message is not answered yet."
+             end
+      message("#{FAILED_AFTER}#{count}: #{one_line(summary)}#{KEPT_WORK}#{tail}")
+    end
+
+    # The failure summary of the failed-turn note at the tail of +messages+
+    # (behind context notes at most), either kind (rolled back, or its work
+    # kept), or nil without one.
+    def failure_summary(messages)
+      list = Array(messages)
+      index = trailing_index(list)
+      return nil unless index
+
+      text = (list[index][:content] || list[index]["content"]).to_s
+      if text.start_with?("#{OPEN}#{FAILED}")
+        text["#{OPEN}#{FAILED}".length..].sub(/\. [^.]*\.\]\z/, "")
+      elsif text.start_with?("#{OPEN}#{FAILED_AFTER}") && text.include?(KEPT_WORK)
+        text[0...text.rindex(KEPT_WORK)].sub(/\A#{Regexp.escape(OPEN + FAILED_AFTER)}\d+ tool steps?: /, "")
+      end
+    end
+
     # @param reason [Symbol, String, nil] the cancel reason (:ctrl_c, :user…)
     # @param seconds [Numeric, nil] how long the turn had run
     # @param shown [Boolean] visible text had streamed (an `[interrupted]`

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -474,6 +474,20 @@ module Samagotchi
         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.
+      def llm_context_for(session)
+        registry = host_registry
+        name = session.model_name.to_s.strip.empty? ? ModelProfile.required_model_name(nil) : session.model_name
+        target = registry.resolve(name)
+        names = registry.lookup_names(session.model_typed || name, resolved: name, target: target)
+        own = session.llm_context
+        LLMContextStrategy.explain(target, names: names, **(own&.resolve_args || {})).summary(own)
+      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.
@@ -612,7 +626,12 @@ module Samagotchi
         # What the worker's server said it served for that model (after a turn).
         if snapshot
           session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"])
+          # 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)
         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"])
         json_response(200, {
@@ -663,8 +682,9 @@ module Samagotchi
       # history again (nor a render of every earlier answer). Live: the
       # worker's GET tail alone (no session file read); else the file. The
       # session part is what the page reads of it (id, status, used memory
-      # names). ?turn_id=: that turn's answer (a queued turn's page re-reads
-      # after the next one started). ?recent=1 (the page since this
+      # names, the model notes its prompt carried: the first turn's build or
+      # a /model records them). ?turn_id=: that turn's answer (a queued
+      # turn's page re-reads after the next one started). ?recent=1 (the page since this
       # release): the timing's records are the newest turn's (#recent_timing),
       # which the page merges by id; without it, the whole timing as before.
       def handle_tail_read(req, id)
@@ -675,12 +695,14 @@ module Samagotchi
         tail = live_tail(id, turn_id: turn_id)
         state = tail && tail["session_state_snapshot"]
         if state.is_a?(Hash)
-          session_json = { id: id, status: state["status"], used_memory_names: Array(state["used_memory_names"]) }
+          session_json = { id: id, status: state["status"], used_memory_names: Array(state["used_memory_names"]),
+                           prompt_notes: Array(state["prompt_notes"]) }
           messages = last_assistant_for_display([tail["answer"]].compact)
         else
           session = @session_class.load(id, state_dir: default_state_dir)
           state = nil
-          session_json = { id: id, status: displayed_status(session), used_memory_names: Array(session.used_memory_names) }
+          session_json = { id: id, status: displayed_status(session), used_memory_names: Array(session.used_memory_names),
+                           prompt_notes: session.prompt_notes.map(&:to_h) }
           messages = last_assistant_for_display(session.messages, turn_id: turn_id)
         end
         live_metrics = state && state["metrics"]
@@ -822,7 +844,12 @@ module Samagotchi
           when 202
             record_history(body, line) if PromptHistory.shell_line?(line)
             json_response(202, reply.json || { status: "accepted" })
-          when 400 then error_response(400, reply.json&.dig("error") || "unknown_command", reply_detail(reply, "not a session command"))
+          when 400
+            # One of this chi's own commands the worker doesn't know: it runs an older chi.
+            name = reply.json&.dig("error") == "unknown_command" && SessionCommands.builtin_name(line)
+            next error_response(501, "not_supported", BridgeClient.stale_worker_message(id, cant: "run #{name}")) if name
+
+            error_response(400, reply.json&.dig("error") || "unknown_command", reply_detail(reply, "not a session command"))
           end
         end
       rescue SessionManager::OwnedByTUI => e
@@ -1514,7 +1541,9 @@ module Samagotchi
           # The context last seen and the token sums, for the ctx meter
           # before the next turn streams (live over saved).
           context: source["context"],
-          tokens: source["tokens"]
+          tokens: source["tokens"],
+          # The memory indexes the session's prompt holds (the ctx tooltip).
+          memory_index: source["memory_index"]
         }
       end
 

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

@@ -21,13 +21,14 @@ import {
   addContext,
 } from "./data.js";
 import { createContextChips } from "./context_chips.js";
+import { chipHtml as llmContextChipHtml, createLlmContextControl } from "./llm_context_chip.js";
 import { renderStable } from "./stable_html.js";
 import { createShownTexts } from "./shown_texts.js";
 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, memChipText, memChipTitle, noteHtml, normalize, steerRowHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy, childrenSummary } from "./format.js";
+import { escapeHtml, memChipText, memChipTitle, noteHtml, normalize, steerRowHtml, ownerBadge, previewForCard, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy, childrenSummary, promptNotesChip } from "./format.js";
 import { createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { BADGES, emptyAnswerHtml, htmlElement, stateBadgeHtml, userBubbleHtml } from "./turn_html.js";
 import { createStageView } from "./stage_view.js";
@@ -75,6 +76,16 @@ const contextChips = createContextChips({
   escapeHtml,
   toast: (text) => showToast(text),
 });
+// The open session's LLM context chip in the info bar, and its popover:
+// /llm-context runs in the session's worker.
+const llmContextControl = createLlmContextControl({
+  el: infoTextEl,
+  escapeHtml,
+  summary: () => (selected ? current.llmContext : null),
+  session: () => selected,
+  running: () => liveTurn.running,
+  run: (line) => runSessionCommand(line),
+});
 const markdownWarningEl = $("#markdownWarning");
 // What the page renders that a notice may stand in for (the server's
 // Web::Capabilities, next to markdown_warning); a notice it names isn't
@@ -353,7 +364,7 @@ function cardHtml(s, { deletable = false, archivable = false, selectable = 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="${escapeHtml(tokensTipText(s.tokens))}">${escapeHtml(ctx)}</span>` : "";
+  const ctxHtml = ctx ? `<span class="ctx" title="${escapeHtml(tokensTipText(s.tokens, undefined, s.memory_index))}">${escapeHtml(ctx)}</span>` : "";
   const waiting = waitingBadge(s);
   const waitingHtml = waiting ? `<span class="attn attn-${waiting.kind}" title="${escapeHtml(waiting.title)}">${escapeHtml(waiting.text)}</span>` : "";
   // A turn a hook stopped wears its own badge, unless the session waits on
@@ -1115,6 +1126,9 @@ function renderSessionView(data) {
   current.usedMemories = s.used_memory_names || [];
   current.preloadedMemories = s.preloaded_memory_names || [];
   current.mutedMemories = s.muted_memory_names || [];
+  current.promptNotes = Array.isArray(s.prompt_notes) ? s.prompt_notes : [];
+  current.llmContext = s.llm_context || null;
+  llmContextControl.refresh();
   current.parentId = s.parent_id || null;
   current.commands = Array.isArray(data.commands) ? data.commands : [];
   if (data.messages && data.messages.length) {
@@ -1219,6 +1233,8 @@ async function readTurnEnd() {
     if (id !== selected) return;
     if (d.session) {
       if (Array.isArray(d.session.used_memory_names)) current.usedMemories = d.session.used_memory_names;
+      // The notes chip: the first turn's build (or a /model) records them.
+      if (Array.isArray(d.session.prompt_notes)) current.promptNotes = d.session.prompt_notes;
       if (d.session.status) current.status = d.session.status;
       if (!(await mergeTurnTiming(id, d.timing))) return;
       liveTurn.timing.finishLine(line);
@@ -1752,7 +1768,7 @@ function updateInfoBar() {
   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 ctxTip = tokensTipText(tokens, undefined, current.timing.memoryIndex);
   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}` : ""}`;
@@ -1765,11 +1781,14 @@ function updateInfoBar() {
   const parentHtml = parentChip ? `<a class="model parent" href="${escapeHtml(sessionHash(current.parentId))}" title="${escapeHtml(parentChip.title)}">delegated by ${escapeHtml(String(current.parentId).slice(0, 8))}</a>` : "";
   // A parent names its delegates; the link opens all sessions.
   const kids = childrenSummary({ id: selected }, allSessions);
+  // The model notes the session's prompt carried.
+  const notes = promptNotesChip(current.promptNotes);
+  const notesHtml = notes ? `<span class="model notes-chip" title="${escapeHtml(notes.title)}">${escapeHtml(notes.text)}</span>` : "";
   const kidsHtml = kids ? `<a class="model children-chip${kids.waitingText ? " waiting" : ""}" href="${escapeHtml(ALL_SESSIONS_HASH)}" title="${escapeHtml(`${kids.title} (all sessions)`)}">${escapeHtml(kids.text)}${kids.waitingText ? ` · <span class="kids-waiting">${escapeHtml(kids.waitingText)}</span>` : ""}</a>` : "";
   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}${kidsHtml}${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||"")}"><bdi>${escapeHtml(current.dir||"")}</bdi></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 session-time"></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}${kidsHtml}${llmContextChipHtml(current.llmContext, escapeHtml)}${notesHtml}${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||"")}"><bdi>${escapeHtml(current.dir||"")}</bdi></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 session-time"></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>`;
   // The session clock ticks every second while a turn runs: only its text
   // changes, the bar's other nodes (a tooltip, a button mid-press) stay.
@@ -2006,10 +2025,13 @@ const streamHandlers = {
   },
   // The turn raised (e.g. the model server stayed unreachable). The worker
   // stays up: it rolls the turn back and hands the prompt back
-  // (prompt_restored), and the prompts queued behind it run as usual.
+  // (prompt_restored), and the prompts queued behind it run as usual. A turn
+  // that got to tool steps stays as it is (kept_steps; no prompt_restored).
   turn_failed: (data) => {
-    liveTurn.failedText = failedTurnText(data);
-    endTurnView("failed", liveTurn.failedText);
+    const text = failedTurnText(data);
+    // Only a rolled-back turn's line waits for its prompt_restored.
+    liveTurn.failedText = Number.isInteger(data.kept_steps) ? null : text;
+    endTurnView("failed", text);
     setLiveStatus("idle");
   },
   // The rolled-back turn left the session: render it from the server again,
@@ -2047,6 +2069,12 @@ const streamHandlers = {
       current.served = null;
       updateInfoBar();
     }
+    // /llm-context changed what the next turn runs under.
+    if (data.llm_context) {
+      current.llmContext = data.llm_context;
+      updateInfoBar();
+      llmContextControl.refresh();
+    }
     if (view.resync) await resync();
     // A card's action that isn't anytime (the step-limit question's
     // /continue) has no bubble: nothing to remove.
@@ -2320,6 +2348,18 @@ async function handleSendCommand(line) {
   }
 }
 
+// A session command from a control (the llm ctx chip), not the composer:
+// its command_ran shows its line and reply, as a typed one's would.
+async function runSessionCommand(line) {
+  if (!selected) return;
+  try {
+    await sendCommand(selected, line, { clientId });
+    followWokenWorker();
+  } catch (e) {
+    addCommandBubble({ label: null, line, text: e.message, failed: true });
+  }
+}
+
 function addCommandBubble(view) {
   removeHintIfEmpty();
   const div = document.createElement("div");

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

@@ -71,14 +71,37 @@ function count(n) {
   return Math.round(n).toLocaleString("en-US");
 }
 
+// A token count as the size readouts word it: "450", "2.0k". As
+// MemoryBundle::IndexSize.count_text.
+function countK(n) {
+  return n >= 1000 ? `${(Math.round(n / 100) / 10).toFixed(1)}k` : String(Math.round(n));
+}
+
+// "~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)": the
+// memory indexes the session's prompt holds (the snapshot's memory_index,
+// measured when the prompt was built); "" without one. As
+// Formatting#memory_index_text (spec/shared/labels_matrix.json).
+export function memoryIndexText(memoryIndex) {
+  if (!memoryIndex || typeof memoryIndex !== "object") return "";
+  const scopes = ["system", "project"]
+    .map((scope) => [scope, num(memoryIndex[scope]?.tokens)])
+    .filter(([, tokens]) => tokens !== null);
+  if (!scopes.length) return "";
+  const total = scopes.reduce((sum, [, tokens]) => sum + tokens, 0);
+  return `~${countK(total)} tokens in this session's prompt (${scopes.map(([scope, tokens]) => `${scope} ${countK(tokens)}`).join(", ")})`;
+}
+
 // 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") {
+// reasoning part) and its cost, when it has any, and the memory indexes
+// its prompt holds (+memoryIndex+, the snapshot's memory_index). 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) {
+  const memory = memoryIndexText(memoryIndex);
+  const memoryLine = memory ? `\nmemory index: ${memory}` : "";
   const prompt = num(tokens?.prompt_sum) || 0;
   const completion = num(tokens?.completion_sum) || 0;
-  if (!prompt && !completion) return title;
+  if (!prompt && !completion) return `${title}${memoryLine}`;
   const cached = num(tokens.cached_sum) || 0;
   const reasoning = num(tokens.reasoning_sum) || 0;
   const parts = [`in ${count(prompt)}`];
@@ -88,7 +111,7 @@ export function tokensTipText(tokens, title = "Context used after the last turn"
   const cost = costText(tokens.cost_sum);
   if (cost) lines.push(`cost: ${cost}`);
   lines.push("this session only, all requests");
-  return lines.join("\n");
+  return `${lines.join("\n")}${memoryLine}`;
 }
 
 // The info bar's speed: the newest generation's decode speed, "" before one.

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

@@ -234,11 +234,14 @@ export function recapPlace(userBubbles, turnsSince) {
 }
 
 // The line a failed turn's bubble shows: a provider error's one-line
-// summary, else the error's message and class.
+// summary, else the error's message and class. A turn whose work stayed
+// (turn_failed's kept_steps; no prompt_restored follows) says so, as the
+// terminal's rollback hint does.
 export function failedTurnText(data) {
   data = data || {};
   const detail = data.summary || `${data.message || "error"}${data.error_class ? ` (${data.error_class})` : ""}`;
-  return `\u2715 turn failed: ${detail}`;
+  const kept = Number.isInteger(data.kept_steps) ? "; partial progress kept (!rollback restores the pre-turn state)" : "";
+  return `\u2715 turn failed: ${detail}${kept}`;
 }
 
 // Whether the server served another model than asked: names equal in any
@@ -298,3 +301,27 @@ export function memChipTitle(names) {
   const list = names || [];
   return list.length ? `memories: ${list.join(", ")}` : "no memories in this session";
 }
+
+// "model_notes_deepseek (system, 612 chars), model_notes_x (project, 80
+// chars)": the model notes the session's prompt carried (its prompt_notes);
+// "" without any. As PromptNote.text (spec/shared/labels_matrix.json).
+export function promptNotesText(notes) {
+  return (Array.isArray(notes) ? notes : [])
+    .filter((note) => note && typeof note.name === "string" && note.name.trim())
+    .map((note) => {
+      const details = [note.scope, Number.isFinite(note.chars) ? `${Math.trunc(note.chars)} chars` : null].filter(Boolean);
+      return details.length ? `${note.name.trim()} (${details.join(", ")})` : note.name.trim();
+    })
+    .join(", ");
+}
+
+// The info bar's model notes chip, for a session whose prompt carried
+// some: "notes: deepseek" (the names without model_notes_), the full line
+// its tooltip; null without notes.
+export function promptNotesChip(notes) {
+  const text = promptNotesText(notes);
+  if (!text) return null;
+  const names = notes.filter((note) => note && typeof note.name === "string" && note.name.trim())
+    .map((note) => note.name.trim().replace(/^model_notes_/, ""));
+  return { text: `notes: ${names.join(", ")}`, title: `model notes in this session's prompt: ${text}` };
+}

data/lib/samagotchi/web/public/index.html

@@ -684,6 +684,18 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 #infoBar #infoArchiveBtn:hover{color:var(--text);background:var(--bg-hover)}
 #infoBar #infoDeleteBtn{background:transparent;color:var(--text-muted);border:1px solid transparent}
 #infoBar #infoDeleteBtn:hover{color:var(--on-solid);background:var(--danger-bg);border-color:var(--danger-bg)}
+/* The LLM context chip (llm_context_chip.js): a model-like chip that opens the strategy popover; accent when the session set its own. */
+#infoBar .meta .llmctx-chip{padding:2px 6px;border-radius:6px;font-size:11px;font-weight:400;border:1px solid transparent;cursor:pointer;font-family:inherit;white-space:nowrap}
+#infoBar .meta .llmctx-chip:hover{color:var(--text);border-color:var(--accent-border);background:var(--accent-bg)}
+#infoBar .meta .llmctx-chip.own{color:var(--accent);border-color:var(--accent-border)}
+.llmctx-form{display:flex;flex-direction:column;gap:8px;margin:0}
+.llmctx-form .ctx-pop-head strong{font-family:inherit}
+.llmctx-field{display:flex;align-items:center;gap:8px}
+.llmctx-field>span{flex:0 0 58px;font-size:12px;color:var(--text-muted)}
+.llmctx-field select,.llmctx-field input{flex:1;min-width:0;box-sizing:border-box;padding:5px 8px;border-radius:7px;border:1px solid var(--border-strong);background:var(--bg-inset);color:var(--text);font:13px/1.4 inherit}
+.llmctx-field select:focus,.llmctx-field input:focus{outline:none;border-color:var(--accent-border)}
+.llmctx-form .llmctx-set{background:var(--accent-bg);color:var(--accent);border-color:var(--accent-border)}
+.llmctx-form .llmctx-set:disabled{opacity:.6;cursor:default}
 /* Attached context (context_chips.js): a row of its own under the meta; not the composer's #chips/.chip. */
 #contextChips{order:5;flex-basis:100%;display:flex;flex-wrap:wrap;gap:6px;align-items:center;min-width:0}
 #contextChips[hidden]{display:none}

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

@@ -38,6 +38,7 @@ export function createLiveTurn(timingDeps) {
       this.timing.drop();
       this.unmatchedMerge = false;
       this.wakeStart = false;
+      this.failedText = null;
       this.releaseDisplay();
     },
   };