samagotchi 0.40.0 → 0.41.0

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.41.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.
@@ -613,6 +627,9 @@ module Samagotchi
         if snapshot
           session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"])
         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, {
@@ -1514,7 +1531,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,6 +21,7 @@ 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";
@@ -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,8 @@ function renderSessionView(data) {
   current.usedMemories = s.used_memory_names || [];
   current.preloadedMemories = s.preloaded_memory_names || [];
   current.mutedMemories = s.muted_memory_names || [];
+  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) {
@@ -1752,7 +1765,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}` : ""}`;
@@ -1769,7 +1782,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}${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)}${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 +2019,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 +2063,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 +2342,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

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();
     },
   };

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

@@ -0,0 +1,194 @@
+// The session bar's LLM context chip: the strategy the next turn runs under
+// ("llm ctx stale,forget"; "· session" when the session set its own), and a
+// popover that sets the session's own strategy, apply rule and budget by
+// running /llm-context in its worker (the command's reply shows in the
+// conversation, like a typed one). The values and where each came from are
+// the session's llm_context (LLMContextStrategy::Explained#summary: the
+// worker's snapshot, a command_ran, or the server's own reading of the
+// session file).
+
+export const STRATEGIES = [
+  { value: "none", label: "none" },
+  { value: "stale", label: "stale" },
+  { value: "stale,forget", label: "stale + forget (experimental)" },
+];
+export const APPLIES = ["payoff", "next_request", "turn_end"];
+
+const DEFAULT = "default";
+const LAYER_ORDER = ["stale", "forget"];
+
+// Layers as one value, in chi's order (stale before forget); unknown ones after.
+export function strategyValue(layers) {
+  if (!layers.length) return "none";
+  const rank = (name) => { const at = LAYER_ORDER.indexOf(name); return at < 0 ? LAYER_ORDER.length : at; };
+  return [...layers].sort((a, b) => rank(a) - rank(b)).join(",");
+}
+
+// The session's own values as the form shows them: a strategy value, an
+// apply rule and a budget word ("64000", "off"); "default" / "" for unset.
+export function ownValues(summary) {
+  const own = summary?.own || {};
+  const strategy = Array.isArray(own.strategy) ? strategyValue(own.strategy) : DEFAULT;
+  const budget = typeof own.budget_tokens === "number" ? (own.budget_tokens > 0 ? String(own.budget_tokens) : "off") : "";
+  return { strategy, apply: own.apply || DEFAULT, budget };
+}
+
+// The chip: its text, tooltip and whether the session set its own; null
+// without a summary (an older worker).
+export function chipModel(summary) {
+  if (!summary || !summary.strategy) return null;
+  const own = summary.strategy_source === "session" || !!summary.own;
+  const budget = summary.budget_tokens ? `${summary.budget_tokens} tokens` : "off";
+  const title = `LLM context strategy: ${summary.strategy} (${summary.strategy_where}); apply ${summary.apply} ` +
+    `(${summary.apply_where}); budget ${budget} (${summary.budget_where}). Click to change it for this session.`;
+  return { text: `llm ctx ${summary.strategy}${own ? " · session" : ""}`, title, own };
+}
+
+export function chipHtml(summary, escapeHtml) {
+  const chip = chipModel(summary);
+  if (!chip) return "";
+  return `<button type="button" class="model llmctx-chip${chip.own ? " own" : ""}" title="${escapeHtml(chip.title)}" ` +
+    `aria-haspopup="dialog">${escapeHtml(chip.text)}</button>`;
+}
+
+// The /llm-context line for the form's values. With +initial+ (the values
+// the form opened with) only the fields the user changed go, so a value the
+// form can't show is never unset by a Set; null when nothing changed.
+// Without it every field goes, "default" for one left to the model, and all
+// of them default is a reset.
+export function commandLine({ strategy = DEFAULT, apply = DEFAULT, budget = "" } = {}, initial = null) {
+  const words = { strategy, apply, budget: String(budget).trim() || DEFAULT };
+  const was = initial && { strategy: initial.strategy, apply: initial.apply, budget: String(initial.budget).trim() || DEFAULT };
+  const fields = Object.keys(words).filter((field) => !was || words[field] !== was[field]);
+  if (!fields.length) return null;
+  if (!was && fields.every((field) => words[field] === DEFAULT)) return "/llm-context reset";
+  return `/llm-context ${fields.map((field) => `${field} ${words[field]}`).join(" ")}`;
+}
+
+// The strategy list, with the session's own value when it isn't one of them
+// (forget alone, a newer chi's layer).
+export function strategyOptions(chosen) {
+  if (chosen === DEFAULT || STRATEGIES.some((s) => s.value === chosen)) return STRATEGIES;
+  return [...STRATEGIES, { value: chosen, label: chosen }];
+}
+
+function option(value, label, chosen, escapeHtml) {
+  return `<option value="${escapeHtml(value)}"${value === chosen ? " selected" : ""}>${escapeHtml(label)}</option>`;
+}
+
+// The popover's form: the values now (each with its source), and the
+// session's own to change.
+export function nowText(summary) {
+  const budget = summary.budget_tokens ? `${summary.budget_tokens} tokens` : "off";
+  return `Now: ${summary.strategy} (${summary.strategy_where}) · apply ${summary.apply} (${summary.apply_where}) · ` +
+    `budget ${budget} (${summary.budget_where})`;
+}
+
+export function formHtml(summary, escapeHtml, { running = false } = {}) {
+  const own = ownValues(summary);
+  const follow = (field) => (summary[`${field}_source`] === "session" ? "follow the model" : `follow the model (${summary[field]})`);
+  return `<form class="llmctx-form"><div class="ctx-pop-head"><strong>LLM context</strong>` +
+    `<span class="ctx-pop-kind">this session</span>` +
+    `<button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div>` +
+    `<div class="ctx-pop-meta llmctx-now">${escapeHtml(nowText(summary))}</div>` +
+    `<label class="llmctx-field"><span>Strategy</span><select name="strategy">` +
+    option(DEFAULT, follow("strategy"), own.strategy, escapeHtml) +
+    strategyOptions(own.strategy).map((s) => option(s.value, s.label, own.strategy, escapeHtml)).join("") + `</select></label>` +
+    `<label class="llmctx-field"><span>Apply</span><select name="apply">` +
+    option(DEFAULT, follow("apply"), own.apply, escapeHtml) +
+    APPLIES.map((a) => option(a, a, own.apply, escapeHtml)).join("") + `</select></label>` +
+    `<label class="llmctx-field"><span>Budget</span><input name="budget" type="text" inputmode="numeric" autocomplete="off" ` +
+    `placeholder="follow the model (64000, 64k or off)" value="${escapeHtml(own.budget)}"></label>` +
+    `<div class="ctx-pop-meta">From the next turn's start. Turning forget on or off re-reads the whole prompt once.` +
+    `${running ? " A turn is running: set it when it ends." : ""}</div>` +
+    `<div class="ctx-pop-actions"><button type="button" class="ctx-pop-detach" data-act="reset">follow the model</button>` +
+    `<button type="submit" class="llmctx-set"${running ? " disabled" : ""}>Set</button></div></form>`;
+}
+
+// The chip's popover. el: where the chip is drawn (#infoText, redrawn every
+// tick: clicks are delegated); summary(): the open session's llm_context;
+// session(): the open session's id; running(): a turn runs; run(line):
+// sends the command.
+export function createLlmContextControl({ el, escapeHtml, summary, session = () => null, running = () => false, run,
+                                          doc = document, win = window }) {
+  const pop = doc.createElement("div");
+  pop.id = "llmContextPopover";
+  pop.className = "ctx-popover llmctx-popover";
+  pop.setAttribute("role", "dialog");
+  pop.hidden = true;
+  doc.body.appendChild(pop);
+  // The values the form opened with, and the session it is for.
+  let initial = null;
+  let openFor = null;
+
+  function place(anchor) {
+    const rect = anchor.getBoundingClientRect();
+    const width = Math.min(360, win.innerWidth - 32);
+    pop.style.width = `${width}px`;
+    pop.style.left = `${Math.max(16, Math.min(rect.left, win.innerWidth - width - 16))}px`;
+    pop.style.bottom = `${Math.max(16, win.innerHeight - rect.top + 8)}px`;
+  }
+
+  function open(anchor) {
+    const data = summary();
+    if (!data) return;
+    initial = ownValues(data);
+    openFor = session();
+    pop.innerHTML = formHtml(data, escapeHtml, { running: running() });
+    pop.hidden = false;
+    place(anchor);
+  }
+
+  function close() {
+    pop.hidden = true;
+    initial = null;
+    openFor = null;
+  }
+
+  function isOpen() { return !pop.hidden; }
+
+  // A new summary (a command_ran, a re-read): an open form keeps what the
+  // user typed; only its "Now:" line and Set's state follow. Another
+  // session closes it.
+  function refresh() {
+    if (!isOpen()) return;
+    const data = summary();
+    if (!data || session() !== openFor) return close();
+    const now = pop.querySelector(".llmctx-now");
+    if (now) now.textContent = nowText(data);
+    const set = pop.querySelector(".llmctx-set");
+    if (set) set.disabled = running();
+  }
+
+  el.addEventListener("click", (e) => {
+    const anchor = e.target.closest(".llmctx-chip");
+    if (!anchor) return;
+    e.stopPropagation();
+    if (isOpen()) close();
+    else open(anchor);
+  });
+  pop.addEventListener("submit", (e) => {
+    e.preventDefault();
+    const form = e.target;
+    const line = commandLine({ strategy: form.elements.strategy.value, apply: form.elements.apply.value,
+                               budget: form.elements.budget.value }, initial);
+    close();
+    if (line) run(line);
+  });
+  pop.addEventListener("click", (e) => {
+    const act = e.target.closest("[data-act]")?.dataset.act;
+    if (act === "close") close();
+    else if (act === "reset") {
+      close();
+      run(commandLine());
+    }
+  });
+  doc.addEventListener("click", (e) => {
+    if (isOpen() && !pop.contains(e.target) && !e.target.closest?.(".llmctx-chip")) close();
+  });
+  doc.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && isOpen()) close();
+  });
+
+  return { close, refresh, get open() { return isOpen(); } };
+}

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

@@ -33,6 +33,9 @@ export function emptySessionState() {
     // worker_version / worker_features): the info bar's stale-worker badge.
     workerVersion: null,
     workerFeatures: [],
+    // The LLM context strategy, apply rule and budget the next turn runs
+    // under, each with its source (the info bar's llm ctx chip), or null.
+    llmContext: null,
     timing: normalizeTiming(),
   };
 }

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

@@ -61,6 +61,9 @@ export function normalizeTiming(data = {}) {
     activeTurn: validRecord(data.active_turn) ? data.active_turn : null,
     // The session's token sums and speeds (SessionMetrics' tokens block).
     tokens: validRecord(data.tokens) ? data.tokens : null,
+    // The memory indexes the session's prompt holds (SessionMetrics'
+    // memory_index), for the ctx tooltip.
+    memoryIndex: validRecord(data.memory_index) ? data.memory_index : null,
   };
 }
 
@@ -96,7 +99,8 @@ export function mergeTiming(timing, data = {}) {
     if (!replaceById(toolRecords, record)) toolRecords.push(record);
   });
   const tokens = fresh.tokens || timing?.tokens || null;
-  return { timing: { ...fresh, turnRecords, toolRecords, tokens }, short: turnRecords.length < count };
+  const memoryIndex = fresh.memoryIndex || timing?.memoryIndex || null;
+  return { timing: { ...fresh, turnRecords, toolRecords, tokens, memoryIndex }, short: turnRecords.length < count };
 }
 
 function replaceById(records, record) {

data/lib/samagotchi/web/session_summary.rb

@@ -62,6 +62,8 @@ module Samagotchi
           # one read of analytics.json.
           ctx_pct: saved&.ctx_pct&.round(1),
           tokens: saved&.tokens,
+          # The memory indexes its prompt held (the card's ctx tooltip).
+          memory_index: saved&.memory_index,
           # Hidden from the strip and the list unless "include archived".
           archived: ArchiveStore.archived?(session_dir),
           project_root: session.project_root(cache: root_cache),