samagotchi 0.55.0 → 0.56.0

data/lib/samagotchi/thinking_command.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "cache_confirm"
 require_relative "thinking"
 
 module Samagotchi
@@ -10,6 +11,7 @@ module Samagotchi
   # model, its host, then thinking.level). A change takes effect at the
   # next turn's start (the REPL and the worker run it between turns), and
   # the reply says what it costs the prompt cache (Thinking.cache_cost).
+  # A costly change asks first (CacheConfirm); --yes (or -y) applies it.
   class ThinkingCommand
     NAME = "/thinking"
     SETTABLE = (Thinking::LEVELS - [Thinking::DEFAULT]).freeze
@@ -17,35 +19,43 @@ module Samagotchi
 
     COST_NOTES = {
       full: "On this model the whole prompt is read again (Gemma's <|think|> starts it).",
-      provider: "The request's thinking fields change: a local llama.cpp or Splash server keeps its cache; " \
-                "hosted APIs (OpenRouter → Claude, OpenAI) may restart theirs.",
+      provider: "The request's thinking fields change: a hosted API (OpenRouter, Claude, OpenAI) reads the whole " \
+                "conversation again.",
       tail: "Only the prompt's tail changes: the cache keeps the rest."
     }.freeze
 
-    # @param engine [Engine] #thinking_explained, #thinking_override(=),
-    #   #session, #thinking_cache_cost
+    # @param engine [Engine] #thinking_explained(own:), #thinking_override(=),
+    #   #session, #thinking_cache_cost, #history?
     # @param save [#call] saves the session after a change
     def initialize(engine:, save:)
       @engine = engine
       @save = save
     end
 
-    # @param args [String] what follows /thinking
-    # @return [Array(String, Boolean)] the reply and whether the level changed
+    # @param args [String] what follows /thinking (--yes anywhere)
+    # @param confirm [Boolean] ask before a costly change (CacheConfirm);
+    #   false applies it at once (chi send, a delegate, a start flag)
+    # @return [Array(String, Boolean, CacheConfirm::Confirm|nil)] the reply,
+    #   whether the level changed, and the confirm it asks for (nothing
+    #   changed then)
     # @raise [ArgumentError] a word that isn't a level (with USAGE)
-    def run(args)
-      word = args.to_s.strip.downcase
-      return [listing(@engine.thinking_explained), false] if word.empty?
+    def run(args, confirm: true)
+      word, yes = CacheConfirm.split(args)
+      return [listing(@engine.thinking_explained), false, nil] if word.empty?
 
       level = word.to_sym
       raise ArgumentError, "unknown thinking level #{word}\n#{USAGE}" unless Thinking::LEVELS.include?(level)
 
       session = @engine.session or raise ArgumentError, "no session yet"
+      own = SETTABLE.include?(level) ? level : nil
       before = @engine.thinking_explained
-      @engine.thinking_override = SETTABLE.include?(level) ? level : nil
+      ask = confirm && !yes ? ask(before, own, word) : nil
+      return ask if ask
+
+      @engine.thinking_override = own
       @save.call(session)
       after = @engine.thinking_explained
-      [[listing(after), *notes(before, after)].join("\n"), true]
+      [[listing(after), *notes(before, after)].join("\n"), true, nil]
     end
 
     # The level, where it came from, and what the session sets itself.
@@ -62,6 +72,18 @@ module Samagotchi
 
     private
 
+    # The reply that asks before a costly change, nil when it needn't.
+    def ask(before, own, word)
+      would = @engine.thinking_explained(own: own)
+      return nil unless before && would
+
+      cost = @engine.thinking_cache_cost
+      return nil unless CacheConfirm.needed?(cost: cost, history: @engine.history?, changed: would.level != before.level)
+
+      step = CacheConfirm.confirm(NAME, word)
+      [[listing(before), "Switching to #{would.level} restarts the prompt cache: #{COST_NOTES[cost]}", step.text].join("\n"), false, step]
+    end
+
     def notes(before, after)
       return [] unless before && after
       return ["(no change to what the next turn runs under)"] if before.level == after.level

data/lib/samagotchi/tools/builtins.rb

@@ -121,7 +121,8 @@ module Samagotchi
       # /model), which chi self reports; unset when unknown, so a value
       # inherited from an outer session never passes for this one. So too
       # the session's own thinking level (SAMAGOTCHI_SESSION_THINKING, unset
-      # without one), which chi self puts first. A
+      # without one), which chi self puts first, and its own reasoning_history
+      # level (SAMAGOTCHI_SESSION_REASONING_HISTORY, the same way). A
       # worker's `chi --model X` default (ModelProfile::MODEL_FROM_CLI_ENV)
       # is unset: it was that run's, not the default of a chi run here.
       def parent_env(kctx, env: ENV)
@@ -129,9 +130,11 @@ module Samagotchi
         id = peers.respond_to?(:session_id) ? peers.session_id.to_s : ""
         model = peers.respond_to?(:model_ref) ? peers.model_ref.to_s : ""
         thinking = peers.respond_to?(:thinking) ? peers.thinking&.to_s : nil
+        history = peers.respond_to?(:reasoning_history) ? peers.reasoning_history&.to_s : nil
         { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
           SESSION_MODEL_ENV => model.empty? ? nil : model,
-          SESSION_THINKING_ENV => thinking }.merge(cli_model_unset(env))
+          SESSION_THINKING_ENV => thinking,
+          SESSION_REASONING_HISTORY_ENV => history }.merge(cli_model_unset(env))
       end
 
       # The unsets that keep a `chi --model X` worker's default from passing
@@ -144,6 +147,7 @@ module Samagotchi
 
       SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
       SESSION_THINKING_ENV = "SAMAGOTCHI_SESSION_THINKING"
+      SESSION_REASONING_HISTORY_ENV = "SAMAGOTCHI_SESSION_REASONING_HISTORY"
 
       # task_create's parent_env, less the unsets of a variable the model
       # set in its env (a SAMAGOTCHI_DEFAULT_MODEL it asked for stays).

data/lib/samagotchi/tools/peers.rb

@@ -9,10 +9,12 @@ module Samagotchi
     # delegate's approval is relayed through (relay: nil when this session
     # can't host one), and the model the session runs on (model_ref: the
     # resolved ref, live after /model), and the session's own thinking level
-    # (thinking: nil without one). Engine hands KernelLoop one that follows its current
+    # (thinking: nil without one) and reasoning_history level
+    # (reasoning_history: nil without one). Engine hands KernelLoop one that follows its current
     # session (Engine::PeerView); this plain one is for specs and a kernel
     # without an Engine.
-    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, :thinking, keyword_init: true) do
+    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, :thinking, :reasoning_history,
+                       keyword_init: true) do
       # @return [Boolean] the turn was canceled (:cancelled is a proc or a value)
       def cancelled?
         cancelled.respond_to?(:call) ? !!cancelled.call : !!cancelled

data/lib/samagotchi/tools/task_runtime.rb

@@ -22,7 +22,8 @@ module Samagotchi
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
-      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING].freeze
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING
+                           SAMAGOTCHI_SESSION_REASONING_HISTORY].freeze
       # task_wait and task_get add it to a task the user stopped (the web's
       # stop-task button), so the model doesn't rerun the job.
       # A record whose pid isn't a process group chi started (missing, 0, 1,

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -26,6 +26,7 @@ require_relative "../llm_context_override"
 require_relative "../model_catalog"
 require_relative "../model_profile"
 require_relative "../thinking"
+require_relative "../reasoning_history"
 require_relative "../sampling_settings"
 require_relative "../served_model"
 require_relative "../project_scope"
@@ -517,7 +518,7 @@ module Samagotchi
       end
 
       # The thinking level +model+ starts at, with where it came from (the
-      # start page's think chip; Thinking::Explained#summary, no session).
+      # start page's think chip; SettingExplained#summary, no session).
       def add_thinking(model, target, names, settings)
         model[:thinking] = Thinking.explain(target, names: names, models: settings).summary
       rescue StandardError
@@ -561,7 +562,7 @@ module Samagotchi
       end
 
       # A session's thinking level with where it came from and its own
-      # (Thinking::Explained#summary), as its worker would resolve it; nil
+      # (SettingExplained#summary), as its worker would resolve it; nil
       # when it can't be. Config and the registry only: no network.
       def thinking_for(session)
         registry = host_registry
@@ -573,6 +574,22 @@ module Samagotchi
         nil
       end
 
+      # A session's reasoning_history level with where it came from and its
+      # own (SettingExplained#summary), as its worker would resolve it; nil
+      # on a native host (it ignores the level) or when it can't be. Config
+      # and the registry only: no network.
+      def reasoning_history_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)
+        return nil unless target.entry&.chat?
+
+        names = registry.lookup_names(session.model_typed || name, resolved: name, target: target)
+        ReasoningHistory.explain(target, names: names, session: session.reasoning_history).summary
+      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.
@@ -820,6 +837,10 @@ module Samagotchi
         session_json = session_json.merge(llm_context: (snapshot && snapshot["llm_context"]) || llm_context_for(session))
         # The thinking level the next turn runs at (the think chip), the same way.
         session_json = session_json.merge(thinking: (snapshot && snapshot["thinking"]) || thinking_for(session))
+        # Its reasoning history (the reasoning chip): the worker's (nil on a
+        # native host), else the server's reading (an older worker, none).
+        history = snapshot&.key?("reasoning_history") ? snapshot["reasoning_history"] : reasoning_history_for(session)
+        session_json = session_json.merge(reasoning_history: history)
         raw_messages = turn_snapshot ? turn_snapshot["messages"] : session.messages
         timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
         json_response(200, {

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

@@ -30,6 +30,7 @@ import {
   chipModel as thinkingChipModel, createThinkingControl,
   withChoice as withThinkingChoice,
 } from "./thinking_chip.js";
+import { createReasoningHistoryControl } from "./reasoning_history_chip.js";
 import { renderInfoBar } from "./info_bar.js";
 import { createShownTexts } from "./shown_texts.js";
 import { MODEL_KEY } from "./model_pick.js";
@@ -67,7 +68,7 @@ import { createLiveTurn } from "./live_turn.js";
 import { installRefClicks, setRefKinds } from "./refs.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
 import { isReportClient, hookNoticeLabel, llmContextNotice, newClientId, noticeLine, promptOps, snapshotEvents, workerGoneText } from "./turn_events.js";
-import { drawCommandBubble, keptCommandBubbles, restoreCommandBubbles } from "./commands.js";
+import { applyConfirm, drawCommandBubble, keptCommandBubbles, restoreCommandBubbles } from "./commands.js";
 import { createComposerCommands, routeComposerLine, routeSessionLine } from "./composer.js";
 import { composerAfterAck, dropEarlyRestores, restoreOnAck } from "./restore.js";
 import { createStreamHandlers } from "./stream_handlers.js";
@@ -134,6 +135,15 @@ const thinkingControl = createThinkingControl({
   running: () => liveTurn.running,
   run: (line) => runSessionCommand(line),
 });
+// The open session's reasoning history chip, after the thinking one (a
+// chat host's only): /reasoning-history runs in the session's worker.
+const reasoningHistoryControl = createReasoningHistoryControl({
+  el: infoTextEl,
+  summary: () => (selected ? current.reasoningHistory : null),
+  session: () => selected,
+  running: () => liveTurn.running,
+  run: (line) => runSessionCommand(line),
+});
 // The start page's thinking chip: the picked model's level, and a level
 // for the next new chat only (sent with its create, then dropped).
 const thinkingNewEl = $("#thinkingNew");
@@ -763,6 +773,7 @@ function renderSessionView(data, { kept = [] } = {}) {
   const activeTurnId = current.timing.activeTurn?.id || null;
   llmContextControl.refresh();
   thinkingControl.refresh();
+  reasoningHistoryControl.refresh();
   if (data.messages && data.messages.length) renderHistory(data.messages);
   else renderHistory(data.history || []);
   restoreCommandBubbles(historyEl, kept);
@@ -1429,6 +1440,7 @@ function updateInfoBar() {
     kids: childrenSummary({ id: selected }, allSessions),
     llmContext: current.llmContext,
     thinking: current.thinking,
+    reasoningHistory: current.reasoningHistory,
     // The model notes the session's prompt carried.
     notes: promptNotesChip(current.promptNotes),
     memories: current.usedMemories,
@@ -1596,6 +1608,7 @@ const streamHandlers = createStreamHandlers({
   contextChips,
   llmContextControl,
   thinkingControl,
+  reasoningHistoryControl,
   sentIds,
   earlyRestores,
   stream: {
@@ -2284,6 +2297,12 @@ const annotateBar = createAnnotateBar({
   },
 });
 historyEl.addEventListener("scroll", annotateBar.schedule);
+// A command bubble's Apply (CacheConfirm): sends the change's --yes line
+// once; its own bubble then says what it did.
+historyEl.addEventListener("click", (e) => {
+  const button = e.target.closest?.("[data-confirm-line]");
+  if (button) applyConfirm(button, runSessionCommand);
+});
 turnDom.scrollEl?.addEventListener("scroll", annotateBar.schedule, true);
 turnRoots().forEach((root) => installCopy(root));
 

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

@@ -148,13 +148,17 @@ export function continueLine(choice, reason = "") {
 // it shows; its command_ran fills that bubble in (`commandId`). So is a
 // command queued for after the running turn (`queued`): its command_queued
 // (waits: "turn_end") draws it `waiting`, saying so, until it ran or was
-// dropped (styled as failed).
+// dropped (styled as failed). A change that restarts the prompt cache asks
+// first (CacheConfirm): `confirm` is the line that applies it, and this
+// tab's own bubble (`own`) gets an Apply button that sends it.
 export const QUEUED_TEXT = "queued: runs after this turn";
+export const APPLY_TEXT = "Apply (restarts the cache)";
 
 export function commandView(event, myId) {
   const own = isOwn(event.client_id, myId);
   const waiting = event.waits === "turn_end";
   return {
+    own,
     label: own ? null : clientLabel(event.client_id),
     line: event.line || "",
     text: event.output || (waiting ? QUEUED_TEXT : ""),
@@ -166,6 +170,7 @@ export function commandView(event, myId) {
     queued: waiting || event.queued === true,
     waiting,
     commandId: event.command_id || null,
+    confirm: typeof event.confirm?.line === "string" ? event.confirm.line : null,
     // A card's action (Nudge…): no bubble unless it says something back.
     hidden: event.card === true && !event.output && event.status !== "error",
   };
@@ -183,8 +188,12 @@ export function historyHasCommandBubble(historyBubbles, line) {
 }
 
 // A command bubble's line and output (again, when its command_ran fills in
-// an anytime command's bubble in place).
-export function drawCommandBubble(div, { label, line, text, busy = false, failed = false, waiting = false, commandId = null }) {
+// an anytime command's bubble in place), and this tab's own change's Apply
+// button when it asks first (a delegated click sends its line: app.js).
+// Command bubbles are page-only: after a reload the button is gone, and
+// the change is typed again.
+export function drawCommandBubble(div, { label, line, text, busy = false, failed = false, waiting = false, commandId = null,
+                                         own = false, confirm = null }) {
   div.className = "bubble command" + (busy ? " busy" : "") + (failed ? " failed" : "") + (waiting ? " queued" : "");
   if (commandId) div.dataset.commandId = commandId;
   div.replaceChildren();
@@ -198,6 +207,30 @@ export function drawCommandBubble(div, { label, line, text, busy = false, failed
     body.textContent = text;
     div.appendChild(body);
   }
+  if (own && confirm) {
+    const apply = document.createElement("button");
+    apply.type = "button";
+    apply.className = "command-confirm";
+    apply.dataset.confirmLine = confirm;
+    apply.title = confirm;
+    apply.textContent = APPLY_TEXT;
+    div.appendChild(apply);
+  }
+}
+
+// A click on a bubble's Apply button: sends its --yes line once (the
+// button is disabled at once), and enables it again when the line wasn't
+// sent (+run+ resolves false or throws), so the user can try again.
+export async function applyConfirm(button, run) {
+  if (!button || button.disabled) return;
+  button.disabled = true;
+  let sent = false;
+  try {
+    sent = await run(button.dataset.confirmLine);
+  } catch {
+    sent = false;
+  }
+  if (!sent) button.disabled = false;
 }
 
 // The prompt and command bubbles in the history, in order, by kind

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

@@ -86,14 +86,18 @@ export function createComposerCommands(deps) {
 
   // 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.
+  // Resolves true once the worker took it, false when it wasn't sent (no
+  // session, a refusal or a network error: the failed bubble says why).
   async function run(line) {
     const id = session();
-    if (!id) return;
+    if (!id) return false;
     try {
       await sendCommand(id, line, { clientId });
       followWokenWorker();
+      return true;
     } catch (e) {
       failed(line, e.message);
+      return false;
     }
   }
 

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

@@ -307,6 +307,9 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .bubble.command.queued .command-output{color:var(--text-faint)}
 .command-line{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-3)}
 .command-output{margin:6px 0 0;white-space:pre-wrap;font-size:12px;color:var(--text-2)}
+.bubble.command .command-confirm{margin-top:8px;padding:3px 10px;border-radius:6px;font:inherit;font-size:12px;cursor:pointer;background:var(--accent-bg);color:var(--accent);border:1px solid var(--accent-border)}
+.bubble.command .command-confirm:hover:not(:disabled){border-color:var(--accent)}
+.bubble.command .command-confirm:disabled{opacity:.55;cursor:default}
 .bubble.continue{border-left:3px solid var(--accent);background:var(--bg-panel);padding:10px 12px}
 .bubble.continue.resolved{border-left-color:var(--text-muted);opacity:.8}
 .continue-text{font-size:14px;color:var(--text);margin-bottom:6px}
@@ -704,9 +707,9 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 #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 and thinking chips (llm_context_chip.js, thinking_chip.js): model-like chips that open their popovers; accent when the session set its own. */
-#infoBar .meta .llmctx-chip,#infoBar .meta .think-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,#infoBar .meta .think-chip:hover{color:var(--text);border-color:var(--accent-border);background:var(--accent-bg)}
-#infoBar .meta .llmctx-chip.own,#infoBar .meta .think-chip.own{color:var(--accent);border-color:var(--accent-border)}
+#infoBar .meta .llmctx-chip,#infoBar .meta .think-chip,#infoBar .meta .rh-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,#infoBar .meta .think-chip:hover,#infoBar .meta .rh-chip:hover{color:var(--text);border-color:var(--accent-border);background:var(--accent-bg)}
+#infoBar .meta .llmctx-chip.own,#infoBar .meta .think-chip.own,#infoBar .meta .rh-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}

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

@@ -1,6 +1,6 @@
 // The session bar's info line (#infoText): the open session's id, its copy
 // chi --attach button, status, model, chain links, parent and delegates,
-// llm ctx and thinking chips, model notes, memories, folder, ctx, speed,
+// llm ctx, thinking and reasoning history chips, model notes, memories, folder, ctx, speed,
 // session clock and the worker's version badge. A lit-html template over a
 // plain model app.js builds (updateInfoBar), so the markup lives here and
 // runs under node --test (spec/web/public/info_bar.test.js).
@@ -15,6 +15,7 @@ import { memChipText, memChipTitle } from "./format.js";
 import { ALL_SESSIONS_HASH, sessionHash } from "./route.js";
 import { chipTemplate as llmContextChip } from "./llm_context_chip.js";
 import { chipTemplate as thinkingChip } from "./thinking_chip.js";
+import { chipTemplate as reasoningHistoryChip } from "./reasoning_history_chip.js";
 
 export const PREV = "←";
 export const NEXT = "→";
@@ -60,7 +61,8 @@ function kidsTemplate(kids) {
 //   id, copied (the copy button just copied), status, model ({text, title,
 //   mismatch}: format.js modelLabel), chain ({prev, next}: chainLinkTemplate's
 //   links or null), parent ({id, title} or null), kids (format.js
-//   childrenSummary), llmContext and thinking (the chips' summaries), notes
+//   childrenSummary), llmContext, thinking and reasoningHistory (the chips'
+//   summaries; reasoningHistory null on a native host: no chip), notes
 //   ({text, title} or null), memories (the used names), dir, ctx ({text,
 //   tip}), speed ({text, tip} or null), clock (the session time's text, ""
 //   for none), worker ({badge, busy} or null).
@@ -68,7 +70,7 @@ export function infoBarHtml(bar) {
   if (!bar) return nothing;
   const attach = `chi --attach ${bar.id}`;
   const memories = bar.memories || [];
-  return html`<div class="meta"><span class="id" title=${bar.id}>${String(bar.id).slice(0, 8)}</span><button type="button" class="copy-attach" title=${`Copy "${attach}" to attach a terminal`}>${bar.copied ? "copied ✓" : "copy chi --attach"}</button><span class=${bar.status ? `status ${bar.status}` : "status"}>${bar.status || ""}</span><span class=${`model${bar.model.mismatch ? " served-mismatch" : ""}`} title=${bar.model.title}>${bar.model.text}</span>${bar.chain?.prev ? chainLinkTemplate(bar.chain.prev, PREV, "The previous link of this chain") : nothing}${bar.chain?.next ? chainLinkTemplate(bar.chain.next, NEXT, "The next link of this chain") : nothing}${bar.parent ? html`<a class="model parent" href=${sessionHash(bar.parent.id)} title=${bar.parent.title}>delegated by ${String(bar.parent.id).slice(0, 8)}</a>` : nothing}${kidsTemplate(bar.kids)}${llmContextChip(bar.llmContext)}${thinkingChip(bar.thinking)}${bar.notes ? html`<span class="model notes-chip" title=${bar.notes.title}>${bar.notes.text}</span>` : nothing}${memories.length ? html`<span class="model mem-chip" title=${memChipTitle(memories)}>${memChipText(memories)}</span>` : nothing}<span class="dir" title=${bar.dir || ""}><bdi>${bar.dir || ""}</bdi></span><span class="model ctx" title=${bar.ctx.tip}>${bar.ctx.text}</span>${bar.speed ? html`<span class="model speed" title=${bar.speed.tip}>${bar.speed.text}</span>` : nothing}${bar.clock ? html`<span class="model session-time">${bar.clock}</span>` : nothing}${workerBadgeTemplate(bar.worker)}</div>`;
+  return html`<div class="meta"><span class="id" title=${bar.id}>${String(bar.id).slice(0, 8)}</span><button type="button" class="copy-attach" title=${`Copy "${attach}" to attach a terminal`}>${bar.copied ? "copied ✓" : "copy chi --attach"}</button><span class=${bar.status ? `status ${bar.status}` : "status"}>${bar.status || ""}</span><span class=${`model${bar.model.mismatch ? " served-mismatch" : ""}`} title=${bar.model.title}>${bar.model.text}</span>${bar.chain?.prev ? chainLinkTemplate(bar.chain.prev, PREV, "The previous link of this chain") : nothing}${bar.chain?.next ? chainLinkTemplate(bar.chain.next, NEXT, "The next link of this chain") : nothing}${bar.parent ? html`<a class="model parent" href=${sessionHash(bar.parent.id)} title=${bar.parent.title}>delegated by ${String(bar.parent.id).slice(0, 8)}</a>` : nothing}${kidsTemplate(bar.kids)}${llmContextChip(bar.llmContext)}${thinkingChip(bar.thinking)}${reasoningHistoryChip(bar.reasoningHistory)}${bar.notes ? html`<span class="model notes-chip" title=${bar.notes.title}>${bar.notes.text}</span>` : nothing}${memories.length ? html`<span class="model mem-chip" title=${memChipTitle(memories)}>${memChipText(memories)}</span>` : nothing}<span class="dir" title=${bar.dir || ""}><bdi>${bar.dir || ""}</bdi></span><span class="model ctx" title=${bar.ctx.tip}>${bar.ctx.text}</span>${bar.speed ? html`<span class="model speed" title=${bar.speed.tip}>${bar.speed.text}</span>` : nothing}${bar.clock ? html`<span class="model session-time">${bar.clock}</span>` : nothing}${workerBadgeTemplate(bar.worker)}</div>`;
 }
 
 // Draws +bar+ into +el+ (#infoText), with the memories in its tooltip.

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

@@ -0,0 +1,174 @@
+// A level chip in the session bar and its popover: the level the next turn
+// runs at ("think low", "reasoning all"; "· session" when the session set
+// its own) and a form with a level select that runs the setting's command
+// in the session's worker (the reply shows in the conversation, like a
+// typed one). The summary is the setting's SettingExplained#summary
+// ({level, source, own}: the worker's snapshot, a command_ran, or the
+// server's own reading of the session file).
+//
+// A config names the setting (thinking_chip.js, reasoning_history_chip.js):
+//   name     the popover's heading ("Thinking")
+//   prefix   the chip's word ("think")
+//   command  the command ("/thinking")
+//   levels   the settable levels (the select's options after "follow")
+//   anchor   the chip's selector (its data attribute: each config's
+//            chipTemplate draws it; clicks are delegated on the same
+//            element as the other chips')
+//   formClass, popoverClass, nowClass   the form's, popover's and "Now:"
+//            line's own classes
+//   when(fresh)   the form's note on when it applies (fresh: the start
+//            page's new chat, thinking only)
+//
+// The start page's new chat (kind NEW_CHAT) has a thinking chip only
+// (thinking_chip.js keeps its choice): the form shows the model's level and
+// takes a choice for the next create.
+
+import { NEW_CHAT, SESSION, popoverPlace } from "./llm_context_chip.js";
+import { html, nothing, render } from "./vendor/lit-html.js";
+
+export const DEFAULT = "default";
+
+// The chip: its text, tooltip and whether the session (or the new chat)
+// set its own; null without a summary (an older worker, or a host the
+// setting means nothing on).
+export function chipModel(cfg, summary, { kind = SESSION } = {}) {
+  if (!summary || !summary.level) return null;
+  const own = !!summary.own;
+  const what = kind === NEW_CHAT ? "the new chat" : "this session";
+  const from = own ? what : summary.source || "the model's own";
+  const title = `${cfg.name}: ${summary.level} (${from}). Click to change it for ${what}.`;
+  return { text: `${cfg.prefix} ${summary.level}${own ? ` · ${kind}` : ""}`, title, own };
+}
+
+// The command line for a select value ("default" unsets the session's own),
+// with --yes: picking a level in the form is the choice, and the form
+// names the cost (CacheConfirm asks nothing then); null when it is what
+// the form opened with.
+export function commandLine(cfg, level, initial = null) {
+  if (initial !== null && level === initial) return null;
+  return `${cfg.command} ${level} --yes`;
+}
+
+// "Now: low (session)", "Now: default (the model's own)".
+export function nowText(summary) {
+  return `Now: ${summary.level} (${summary.source || "the model's own"})`;
+}
+
+const option = (value, label, chosen) => html`<option value=${value} ?selected=${value === chosen}>${label}</option>`;
+
+// The popover's form (a lit-html template). For the new chat (kind
+// NEW_CHAT), +summary+ is the model's and +choice+ the level the form
+// shows; +now+ is the summary its "Now:" line reads (refresh passes a
+// newer one, the rest stays as the form opened).
+export function formTemplate(cfg, summary, { running = false, kind = SESSION, choice = null, now = summary } = {}) {
+  const fresh = kind === NEW_CHAT;
+  const chosen = (fresh ? choice : summary.own) || DEFAULT;
+  const follow = summary.own && !fresh ? "follow the model" : `follow the model (${summary.level})`;
+  return html`<form class=${`${cfg.formClass} llmctx-form`}><div class="ctx-pop-head"><strong>${cfg.name}</strong
+    ><span class="ctx-pop-kind">${fresh ? NEW_CHAT : "this session"}</span
+    ><button type="button" class="ctx-pop-close" data-act="close" aria-label="Close">×</button></div
+    ><div class=${`ctx-pop-meta ${cfg.nowClass}`}>${nowText(now)}</div
+    ><label class="llmctx-field"><span>Level</span><select name="level">${option(DEFAULT, follow, chosen)}${
+      cfg.levels.map((level) => option(level, level, chosen))}</select></label
+    ><div class="ctx-pop-meta">${cfg.when(fresh)}${running ? " A turn is running: it applies after this turn." : ""}</div
+    ><div class="ctx-pop-actions"><button type="submit" class="llmctx-set">Set</button></div></form>`;
+}
+
+// The chip's popover, as createLlmContextControl's: el is where the chip
+// is drawn (clicks are delegated: #infoText, info_bar.js);
+// summary(): the open session's summary; session(): its id; running(): a
+// turn runs; run(line): sends the command. The start page's (kind
+// NEW_CHAT): summary() is the picked model's, choice() the pending level
+// and choose(next) takes a Set's (null for "follow the model"). id and
+// anchor (the chip's selector, by default its data attribute) keep it
+// apart from the other controls on the same element (the anchor defaults
+// to the config's).
+export function createLevelControl({ cfg, el, summary, session = () => null, running = () => false, run,
+                                     kind = SESSION, choice = () => null, choose = null,
+                                     id, anchor: anchorSel = cfg.anchor,
+                                     doc = document, win = window }) {
+  const fresh = kind === NEW_CHAT;
+  const pop = doc.createElement("div");
+  pop.id = id;
+  pop.className = `ctx-popover ${cfg.popoverClass}`;
+  pop.setAttribute("role", "dialog");
+  pop.hidden = true;
+  doc.body.appendChild(pop);
+  let initial = null;
+  let openFor = null;
+  // What the open form was drawn from: the model's or session's summary
+  // and the form's options. A closed popover is empty, so each open draws
+  // a fresh form (an unsent pick is gone).
+  let shown = null;
+  const draw = (now) => render(formTemplate(cfg, shown.data, { ...shown.opts, now }), pop);
+
+  function place(anchor) {
+    const width = Math.min(320, win.innerWidth - 32);
+    pop.style.width = `${width}px`;
+    pop.style.maxHeight = "";
+    const at = popoverPlace(anchor.getBoundingClientRect(), { width, height: pop.offsetHeight,
+                                                              innerWidth: win.innerWidth, innerHeight: win.innerHeight });
+    pop.style.left = `${at.left}px`;
+    pop.style.top = at.top === undefined ? "" : `${at.top}px`;
+    pop.style.bottom = at.bottom === undefined ? "" : `${at.bottom}px`;
+    if (at.maxHeight !== undefined) pop.style.maxHeight = `${at.maxHeight}px`;
+  }
+
+  function open(anchor) {
+    const data = summary();
+    if (!data) return;
+    initial = (fresh ? choice() : data.own) || DEFAULT;
+    openFor = session();
+    shown = { data, opts: { running: running(), kind, choice: choice() } };
+    draw(data);
+    pop.hidden = false;
+    place(anchor);
+  }
+
+  function close() {
+    pop.hidden = true;
+    initial = null;
+    openFor = null;
+    shown = null;
+    render(nothing, pop);
+  }
+
+  function isOpen() { return !pop.hidden; }
+
+  // A new summary: an open form keeps the user's pick; only "Now:" follows
+  // (the same template again: lit writes that line alone).
+  function refresh() {
+    if (!isOpen()) return;
+    const data = summary();
+    if (!data || session() !== openFor) return close();
+    draw(data);
+  }
+
+  el.addEventListener("click", (e) => {
+    const anchor = e.target.closest(anchorSel);
+    if (!anchor) return;
+    e.stopPropagation();
+    if (isOpen()) close();
+    else open(anchor);
+  });
+  pop.addEventListener("submit", (e) => {
+    e.preventDefault();
+    const level = e.target.elements.level.value;
+    const was = initial;
+    close();
+    if (fresh) return choose(level === DEFAULT ? null : level);
+    const line = commandLine(cfg, level, was);
+    if (line) run(line);
+  });
+  pop.addEventListener("click", (e) => {
+    if (e.target.closest("[data-act]")?.dataset.act === "close") close();
+  });
+  doc.addEventListener("click", (e) => {
+    if (isOpen() && !pop.contains(e.target) && !e.target.closest?.(anchorSel)) close();
+  });
+  doc.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && isOpen()) close();
+  });
+
+  return { close, refresh, get open() { return isOpen(); } };
+}

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

@@ -22,7 +22,7 @@ export const RECENT_KEY = "chi_model_recent";
 
 // The payload's models as rows: {name, host, id, isDefaultHost}, and
 // sampling (the configured request parameters as /model words them) when
-// the model has some, thinking (the level it starts at, Thinking::Explained#summary),
+// the model has some, thinking (the level it starts at, SettingExplained#summary),
 // and llm_context (the LLM context it starts under,
 // LLMContextStrategy::Explained#summary) when the server sent one, and
 // configured when the host declares the id (hosts.<name>.models), and