samagotchi 0.51.0 → 0.53.0

data/lib/samagotchi/thinking_command.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "thinking"
+
+module Samagotchi
+  # /thinking, the session's own thinking level (Session#thinking): with no
+  # argument, the level the next turn runs at and where it came from;
+  # `/thinking off|low|medium|high` sets the session's own, `/thinking
+  # default` unsets it (the session follows the process default, the
+  # 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).
+  class ThinkingCommand
+    NAME = "/thinking"
+    SETTABLE = (Thinking::LEVELS - [Thinking::DEFAULT]).freeze
+    USAGE = "usage: #{NAME} [#{Thinking::LEVELS.join("|")}]".freeze
+
+    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.",
+      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 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
+    # @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?
+
+      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"
+      before = @engine.thinking_explained
+      @engine.thinking_override = SETTABLE.include?(level) ? level : nil
+      @save.call(session)
+      after = @engine.thinking_explained
+      [[listing(after), *notes(before, after)].join("\n"), true]
+    end
+
+    # The level, where it came from, and what the session sets itself.
+    def listing(explained)
+      return "thinking: can't be resolved for this model" unless explained
+
+      lines = ["thinking: #{explained.label}"]
+      unless explained.own
+        lines << "  this session's own: none (follows chi web --thinking / SAMAGOTCHI_THINKING_LEVEL, the model, " \
+                 "its host, then thinking.level)"
+      end
+      lines.join("\n")
+    end
+
+    private
+
+    def notes(before, after)
+      return [] unless before && after
+      return ["(no change to what the next turn runs under)"] if before.level == after.level
+
+      ["From the next turn's start (a running turn keeps its own).", COST_NOTES[@engine.thinking_cache_cost]].compact
+    end
+  end
+end

data/lib/samagotchi/tools/builtins.rb

@@ -119,15 +119,19 @@ module Samagotchi
       # wrapper. The session's id, "chi" without one. And the model the
       # session runs on (SAMAGOTCHI_SESSION_MODEL, read live, so right after
       # /model), which chi self reports; unset when unknown, so a value
-      # inherited from an outer session never passes for this one. A
+      # 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
       # 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)
         peers = kctx.peers
         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
         { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
-          SESSION_MODEL_ENV => model.empty? ? nil : model }.merge(cli_model_unset(env))
+          SESSION_MODEL_ENV => model.empty? ? nil : model,
+          SESSION_THINKING_ENV => thinking }.merge(cli_model_unset(env))
       end
 
       # The unsets that keep a `chi --model X` worker's default from passing
@@ -139,6 +143,7 @@ module Samagotchi
       end
 
       SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+      SESSION_THINKING_ENV = "SAMAGOTCHI_SESSION_THINKING"
 
       # 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

@@ -8,10 +8,11 @@ module Samagotchi
     # canceled (a waiting tool returns on it), and the question flow a
     # 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). Engine hands KernelLoop one that follows its current
+    # resolved ref, live after /model), and the session's own thinking level
+    # (thinking: 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, keyword_init: true) do
+    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, :thinking, 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,7 @@ 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].freeze
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING].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.51.0"
+  VERSION = "0.53.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/vision_support.rb

@@ -24,7 +24,7 @@ module Samagotchi
     # @param target [HostRegistry::ModelTarget]
     # @param profile [ModelProfile, nil] the model's prompt profile (native)
     # @param adapter [LLM::OpenAIChat, nil] the chat host's adapter
-    # @param models [Hash, nil] ConfigFile.model_settings (specs)
+    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
     # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
     # @return [Answer]
     def self.for(target, names:, profile: nil, adapter: nil, models: nil)
@@ -51,8 +51,9 @@ module Samagotchi
       rescue StandardError
         {}
       end
-      key, value = ConfigFile.model_setting(names, :vision, models: models)
-      return Answer.new(value: value, reason: value ? nil : "models: #{key} sets vision: false") if key
+      if (setting = ConfigFile.model_setting(names, :vision, models: models))
+        return Answer.new(value: setting.value, reason: setting.value ? nil : "models: #{setting.key} sets vision: false")
+      end
       return nil if entry.vision.nil?
 
       Answer.new(value: entry.vision, reason: entry.vision ? nil : "hosts.#{entry.name} sets vision: false")

data/lib/samagotchi/web/app.rb

@@ -9,7 +9,9 @@ require "uri"
 require "rack"
 require "rack/request"
 
+require_relative "../analytics_file"
 require_relative "../client_id"
+require_relative "../delivery"
 require_relative "../answer_tail"
 require_relative "../bridge_client"
 require_relative "../bridge/bounded_queue"
@@ -23,6 +25,7 @@ require_relative "../host_registry"
 require_relative "../llm_context_override"
 require_relative "../model_catalog"
 require_relative "../model_profile"
+require_relative "../thinking"
 require_relative "../sampling_settings"
 require_relative "../served_model"
 require_relative "../project_scope"
@@ -476,6 +479,7 @@ module Samagotchi
           summary = SamplingSettings.summary(target, names: names, models: settings)
           model[:sampling] = summary if summary
           add_llm_context(model, target, names, settings)
+          add_thinking(model, target, names, settings)
         end
       rescue StandardError
         nil
@@ -489,6 +493,14 @@ module Samagotchi
         nil
       end
 
+      # The thinking level +model+ starts at, with where it came from (the
+      # start page's think chip; Thinking::Explained#summary, no session).
+      def add_thinking(model, target, names, settings)
+        model[:thinking] = Thinking.explain(target, names: names, models: settings).summary
+      rescue StandardError
+        nil
+      end
+
       # The served model a session's last generation reported (analytics.json,
       # SessionMetrics#persist), for a session no worker runs: shown only
       # while the name it answered is still the session's model, as
@@ -525,6 +537,19 @@ module Samagotchi
         LLMContextStrategy.for_session(session, registry: host_registry)
       end
 
+      # A session's thinking level with where it came from and its own
+      # (Thinking::Explained#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
+        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)
+        Thinking.explain(target, names: names, session: session.thinking).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.
@@ -607,6 +632,11 @@ module Samagotchi
         llm_context, error = request_llm_context(body["llm_context"])
         return error if error
 
+        # thinking: the session's own thinking level (the start page's think
+        # chip; chi --thinking), checked the same way.
+        thinking, error = request_thinking(body["thinking"])
+        return error if error
+
         folder = dir ? { working_directory: dir } : {}
         # model: the model the session starts on (the start page's picker,
         # spelled as GET /api/models lists it); blank means the default.
@@ -617,7 +647,8 @@ module Samagotchi
         # until that turn is saved.
         preview = idle ? body["preview"].to_s.strip : ""
         folder[:title] = preview unless preview.empty?
-        folder[:llm_context] = llm_context if llm_context
+        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking)
+        folder[:setup] = setup unless setup.empty?
         begin
           session = @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
         rescue ModelProfile::MissingModel => e
@@ -635,8 +666,8 @@ module Samagotchi
 
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
       # link of that session's chain (SessionManager.continue_session), in its
-      # folder, on its model and with its llm_context, so dir, model and
-      # llm_context are refused beside it. 409 continued (with next_id, the
+      # folder, on its model and with its llm_context and thinking level, so
+      # dir, model, llm_context and thinking are refused beside it. 409 continued (with next_id, the
       # link that continues it already: the page opens that one),
       # open_children (ids), folder_gone, busy, scratch or owned_by_tui.
       def handle_continue(body, prompt, idle)
@@ -644,9 +675,9 @@ module Samagotchi
         unless given.is_a?(String) && !given.strip.empty?
           return error_response(400, "invalid_continues", "continues is a session id")
         end
-        if (fields = %w[dir model model_name llm_context].select { |key| body.key?(key) }).any?
+        if (fields = %w[dir model model_name llm_context thinking].select { |key| body.key?(key) }).any?
           return error_response(400, "invalid_continues",
-                                "continues takes the previous session's folder, model and llm_context; " \
+                                "continues takes the previous session's folder, model, llm_context and thinking; " \
                                 "leave out #{fields.join(", ")}")
         end
 
@@ -701,6 +732,20 @@ module Samagotchi
         [nil, error_response(400, "invalid_llm_context", e.message)]
       end
 
+      # The create request's "thinking" (a level word as /thinking takes it,
+      # "default" for none) as the session's own level: [level, nil] (nil
+      # when absent or default), or [nil, a 400 response] for anything else.
+      def request_thinking(raw)
+        return [nil, nil] if raw.nil?
+
+        word = raw.is_a?(String) ? raw.strip.downcase : nil
+        unless word && Thinking::LEVELS.map(&:to_s).include?(word)
+          return [nil, error_response(400, "invalid_thinking", "thinking is one of #{Thinking::LEVELS.join(", ")}")]
+        end
+
+        [Thinking.session_level(word), nil]
+      end
+
       def handle_show(req, id)
         # The page's light re-reads: never the whole conversation.
         return handle_cards_read(id) if req.params["cards"] == "1"
@@ -750,6 +795,8 @@ module Samagotchi
         # 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))
+        # 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))
         raw_messages = turn_snapshot ? turn_snapshot["messages"] : session.messages
         timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
         json_response(200, {
@@ -1066,7 +1113,9 @@ module Samagotchi
         return error_response(400, "bad_images", images) if images.is_a?(String)
 
         delivery = body["delivery"] || body[:delivery]
-        return error_response(400, "bad_delivery", "delivery must be a string") unless delivery.nil? || delivery.is_a?(String)
+        if (refused = Delivery.refusal(delivery))
+          return error_response(400, refused[:error], refused[:detail])
+        end
 
         result = SessionManager.deliver_turn(id, prompt: prompt.to_s, client_id: client_id, images: images,
                                                  delivery: delivery, state_dir: @state_dir, manager: @manager,
@@ -1674,13 +1723,7 @@ module Samagotchi
       end
 
       def read_analytics(session_id)
-        path = File.join(@session_class.session_dir(session_id, state_dir: default_state_dir), "analytics.json")
-        return {} unless File.file?(path)
-
-        data = JSON.parse(File.read(path))
-        data.is_a?(Hash) ? data : {}
-      rescue JSON::ParserError, SystemCallError
-        {}
+        AnalyticsFile.read(@session_class.session_dir(session_id, state_dir: default_state_dir)) || {}
       end
 
       def merge_timing_records(persisted, live)

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

@@ -26,14 +26,18 @@ import {
   chipHtml as llmContextChipHtml, chipModel as llmContextChipModel, choiceWords, createLlmContextControl, NEW_CHAT,
   withChoice,
 } from "./llm_context_chip.js";
+import {
+  chipHtml as thinkingChipHtml, chipModel as thinkingChipModel, createThinkingControl,
+  withChoice as withThinkingChoice,
+} from "./thinking_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, promptNotesChip } from "./format.js";
-import { createTurnView, turnHistoryHtml } from "./turn_view.js";
+import { escapeHtml, memChipText, memChipTitle, noteHtml, normalize, steerRowHtml, ownerBadge, previewForCard, firstPreview, relativeTime, failedTurnText, modelLabel, deleteConfirmText, recapLabel, canStopSession, goneSessionNotice, withLiveStatus, withoutWorker, recapPlace, delegatedBy, childrenSummary, promptNotesChip } from "./format.js";
+import { createTurnView, turnHistoryNodes } from "./turn_view.js";
 import { BADGES, emptyAnswerHtml, htmlElement, stateBadgeHtml, userBubbleHtml } from "./turn_html.js";
 import { createStageView } from "./stage_view.js";
 import { createFamilyPop, familyChipHtml, familyRowsHtml } from "./families_view.js";
@@ -58,12 +62,13 @@ import { applySessionEvent, batchCounts, batchTargets, batchToastText, families,
 import { createNotifications } from "./notifications.js";
 import { tabTitle, topBarTitle } from "./session_title.js";
 import { restartConfirmText, versionNotice, workerBadge } from "./update_notice.js";
+import { anchorInsertIndex, commandAnchor, isShellCommandLine, keepsCommandBubble } from "./kept_commands.js";
 import {
-  appendAboveLiveTiming, cancelLineText, elapsedSince, formatDuration, mergeTiming, normalizeTiming, STOPPED_LINE_CLASS,
+  appendAboveLiveTiming, cancelLineText, formatDuration, mergeTiming, normalizeTiming, sessionDurationNow, STOPPED_LINE_CLASS,
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
-import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, historyHasCommandBubble, hookNoticeLabel, initWaitLine, isOwn, llmContextHover, llmContextLine, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
+import { clientLabel, commandView, isReportClient, displayWait, dropEarlyRestores, emptyRetryLine, historyHasCommandBubble, hookNoticeLabel, initWaitLine, isOwn, llmContextHover, llmContextLine, sessionCommandLine, keepEarlyRestore, newClientId, noticeLine, promptOps, reminderText, restoreAction, composerAfterAck, restoreOnAck, replaysDrawnTurn, retryStatusLine, snapshotEvents, steerChoiceRoute, steerCutLine, startPageReplyOrHint, turnOutput, unknownCommandHint, webLocalReply, workerGoneText } from "./turn_events.js";
 
 const $ = (s) => document.querySelector(s);
 const topStripEl = $("#topStrip");
@@ -117,6 +122,41 @@ const llmContextNewControl = createLlmContextControl({
   id: "llmContextNewPopover",
   anchor: "#llmContextNew",
 });
+// The open session's thinking chip, beside the llm ctx one: /thinking runs
+// in the session's worker.
+const thinkingControl = createThinkingControl({
+  el: infoTextEl,
+  summary: () => (selected ? current.thinking : 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");
+let newChatThinking = null;
+const newChatThinkingSummary = () => (modelPickEl.hidden ? null : modelPicker.chosenRow()?.thinking || null);
+const thinkingNewControl = createThinkingControl({
+  el: thinkingNewEl,
+  summary: newChatThinkingSummary,
+  kind: NEW_CHAT,
+  choice: () => newChatThinking,
+  choose: (next) => {
+    newChatThinking = next;
+    renderNewChatThinking();
+    promptEl.focus();
+  },
+  id: "thinkingNewPopover",
+  anchor: "#thinkingNew",
+});
+function renderNewChatThinking() {
+  const chip = thinkingChipModel(withThinkingChoice(newChatThinkingSummary(), newChatThinking), { kind: NEW_CHAT });
+  thinkingNewEl.hidden = !chip;
+  if (!chip) return thinkingNewControl.close();
+  thinkingNewEl.textContent = chip.text;
+  thinkingNewEl.title = chip.title;
+  thinkingNewEl.classList.toggle("own", chip.own);
+}
 // Hidden without the model's values (the list not in, an older server).
 function renderNewChatLlmContext() {
   const chip = llmContextChipModel(withChoice(newChatLlmSummary(), newChatLlmContext), { kind: NEW_CHAT });
@@ -1057,6 +1097,11 @@ function updateComposerMode() {
       newChatLlmContext = null;
       renderNewChatLlmContext();
     }
+    thinkingNewControl.close();
+    if (newChatThinking) {
+      newChatThinking = null;
+      renderNewChatThinking();
+    }
   }
   const running = liveTurn.running && !!selected;
   cancelBtn.style.display = running ? "" : "none";
@@ -1233,8 +1278,9 @@ async function resync({ endText = null } = {}) {
       return;
     }
     if (id !== selected) return;
+    const kept = keptCommandBubbles(id);
     resetTurnView();
-    renderSessionView(data);
+    renderSessionView(data, { kept });
     // Preview is read-only: a worker is woken only by POST /turn, so attach
     // only when a live bridge exists.
     selectSeq = typeof data.last_event_seq === "number" ? (data.last_event_id || data.last_event_seq) : null;
@@ -1249,10 +1295,45 @@ async function resync({ endText = null } = {}) {
   }
 }
 
+// The prompt and command bubbles in the history, in order, by kind
+// (kept_commands.js): a prompt, a `!cmd`'s (saved, so redrawn) or another.
+function historyAnchors() {
+  const els = [...historyEl.querySelectorAll(".bubble.user, .bubble.command")];
+  const kinds = els.map((el) => {
+    if (el.classList.contains("user")) return "user";
+    const line = el.querySelector(":scope > .command-line")?.textContent;
+    return !el.classList.contains("failed") && isShellCommandLine(line) ? "shell" : "other";
+  });
+  return { els, kinds };
+}
+
+// This session's own command bubbles (/help, /model …: drawn by this page,
+// never saved) with their anchors, before a resync redraws the history.
+// In-flight ones (busy, queued) are left out: the snapshot draws them again.
+function keptCommandBubbles(id) {
+  const { els, kinds } = historyAnchors();
+  return els
+    .map((el, i) => ({ el, anchor: commandAnchor(kinds, i) }))
+    .filter(({ el }) => el.dataset.keptFor === id && !el.classList.contains("busy") && !el.classList.contains("queued"))
+    .filter(({ el }) => keepsCommandBubble(el.querySelector(":scope > .command-line")?.textContent));
+}
+
+// The kept bubbles back into the redrawn history, each after its turn.
+function restoreCommandBubbles(kept) {
+  if (!kept.length) return;
+  historyEl.querySelector(".hint")?.remove();
+  kept.forEach(({ el, anchor }) => {
+    const { els, kinds } = historyAnchors();
+    const at = anchorInsertIndex(kinds, anchor);
+    if (at < els.length) els[at].before(el);
+    else historyEl.appendChild(el);
+  });
+}
+
 // A session view: its messages, then the turn in progress and the queued
 // prompts (a live worker's snapshot) replayed through the stream handlers,
 // then a pending question.
-function renderSessionView(data) {
+function renderSessionView(data, { kept = [] } = {}) {
   const s = data.session;
   setMarkdownWarning(data.markdown_warning);
   setCapabilities(data.capabilities);
@@ -1279,20 +1360,23 @@ function renderSessionView(data) {
   current.promptNotes = Array.isArray(s.prompt_notes) ? s.prompt_notes : [];
   current.llmContext = s.llm_context || null;
   llmContextControl.refresh();
+  current.thinking = s.thinking || null;
+  thinkingControl.refresh();
   current.parentId = s.parent_id || null;
   current.continues = s.continues || null;
   current.commands = Array.isArray(data.commands) ? data.commands : [];
   if (data.messages && data.messages.length) {
     const first = data.messages.find((m) => m.role === "user");
-    if (first && first.content) current.firstPreview = normalize(first.content).slice(0,80) + (normalize(first.content).length>80?"…":"");
+    if (first && first.content) current.firstPreview = firstPreview(first.content);
     renderHistory(data.messages);
   } else {
     renderHistory(data.history || []);
     if (!current.firstPreview && data.history && data.history.length) {
-      const txt = normalize(String(data.history[0]||"")).slice(0,80);
-      if(txt) current.firstPreview = txt;
+      const txt = firstPreview(data.history[0]);
+      if (txt) current.firstPreview = txt;
     }
   }
+  restoreCommandBubbles(kept);
   // A failed turn's prompt went back to the user: shown after the
   // conversation, marked failed, as it was live (prompt_restored).
   if (data.failed_turn) {
@@ -1352,7 +1436,7 @@ function renderHistory(items) {
     return;
   }
   if (typeof items[0] === "object" && items[0].role) {
-    historyEl.innerHTML = turnHistoryHtml(items, current.timing, { thumbs: (images) => thumbsHtml(selected, images) });
+    historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsHtml(selected, images) }));
   } else {
     historyEl.innerHTML = items.map((c) => `<div class="bubble output">${escapeHtml(c)}</div>`).join("");
   }
@@ -1965,7 +2049,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>${chainHtml}${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 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>${chainHtml}${parentHtml}${kidsHtml}${llmContextChipHtml(current.llmContext, escapeHtml)}${thinkingChipHtml(current.thinking, 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>`;
   // 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.
   renderStable(infoTextEl, metaHtml, { ".session-time": timingText });
@@ -2020,10 +2104,7 @@ function memoriesTooltip(used, preloaded, muted) {
 }
 
 function currentSessionDuration() {
-  if (liveTurn.running && current.timing.startedAt) {
-    return elapsedSince(current.timing.startedAt);
-  }
-  return current.timing.sessionDurationMs;
+  return sessionDurationNow(current.timing, liveTurn.running);
 }
 
 // The stage takes a running turn's rows (its extras); else the history.
@@ -2281,6 +2362,12 @@ const streamHandlers = {
       updateInfoBar();
       llmContextControl.refresh();
     }
+    // /thinking (or /model) changed the level the next turn runs at.
+    if (data.thinking) {
+      current.thinking = data.thinking;
+      updateInfoBar();
+      thinkingControl.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. An anytime or queued
@@ -2433,10 +2520,27 @@ function handleCreate() {
 
 async function handleSendTurn() {
   if (current.owner === "tui") return;
-  const prompt = turnText(promptEl.value, chips);
+  let prompt = turnText(promptEl.value, chips);
   if (!prompt) return;
   // An image-only send's text is its placeholders: not for ↑.
   const typed = promptEl.value.trim() !== "";
+  // /cut TEXT and /queue TEXT (the terminals' words for a delivery): the
+  // text as a cut, or the page's own answer (/queue, the bare word).
+  let delivery = null;
+  const choice = steerChoiceRoute(prompt, { running: liveTurn.running && !!selected });
+  if (choice?.reply) {
+    if (selected) addCommandBubble({ label: null, line: prompt, text: choice.reply });
+    else showNotice(choice.reply);
+    promptEl.value = "";
+    fitPrompt();
+    return;
+  }
+  // The composer holds the line as typed until the ack (composerAfterAck).
+  const line = prompt;
+  if (choice) {
+    prompt = choice.send;
+    delivery = choice.delivery || null;
+  }
   if (!selected) {
     // The start page's own reply (a web-local command) or the hint for a
     // typo: neither needs a session, so none is made for it (2.29).
@@ -2450,10 +2554,13 @@ async function handleSendTurn() {
     actionBtn.disabled = true;
     try {
       const s = await createIdleSession({ dir: scope.dir, model: chosenModel(), preview: prompt,
-                                          llm_context: choiceWords(newChatLlmContext) });
+                                          llm_context: choiceWords(newChatLlmContext),
+                                          thinking: newChatThinking || undefined });
       // The choice was for this chat only.
       newChatLlmContext = null;
       renderNewChatLlmContext();
+      newChatThinking = null;
+      renderNewChatThinking();
       addCreatedSession(s);
       await select(s.id);
     } catch (e) {
@@ -2485,7 +2592,7 @@ async function handleSendTurn() {
   const echo = makeUserBubble(prompt, { state: "queued", own: true, images: sending });
   if (!turnDom.holds?.()) historyEl.scrollTop = historyEl.scrollHeight;
   if (!current.firstPreview || current.firstPreview==="—") {
-    current.firstPreview = normalize(prompt).slice(0,80) + (normalize(prompt).length>80?"…":"");
+    current.firstPreview = firstPreview(prompt);
     updateInfoBar();
   }
   actionBtn.disabled = true;
@@ -2493,7 +2600,7 @@ async function handleSendTurn() {
     for (const chip of sending) {
       if (!chip.ref) chip.ref = await uploadImage(selected, chip.file, chip.name);
     }
-    const ack = await sendTurn(selected, prompt, { clientId, images: turnRefs(sending), history: typed });
+    const ack = await sendTurn(selected, prompt, { clientId, images: turnRefs(sending), history: typed, delivery });
     if (ack?.command_id) {
       // The worker knew it as a command (its list was newer than ours):
       // its command_ran shows it, not a prompt bubble.
@@ -2509,7 +2616,7 @@ async function handleSendTurn() {
     // (and images) go back into the composer, without replacing text typed
     // since (4.13). The composer still holds the text just sent: it goes.
     const restored = restoreOnAck(ack?.enqueued_id, earlyRestores, { myId: clientId, sentIds });
-    promptEl.value = composerAfterAck({ sent: prompt, current: promptEl.value, refill: restored?.refill || "" });
+    promptEl.value = composerAfterAck({ sent: line, current: promptEl.value, refill: restored?.refill || "" });
     fitPrompt();
     clearChips();
     if (restored?.images?.length) setChips(restoredChips(selected, restored.images));
@@ -2589,6 +2696,8 @@ async function runSessionCommand(line) {
 function addCommandBubble(view) {
   removeHintIfEmpty();
   const div = document.createElement("div");
+  // Page-only: kept across a resync of this session (keptCommandBubbles).
+  if (selected) div.dataset.keptFor = selected;
   drawCommandBubble(div, view);
   const follow = isNearBottom();
   appendToHistory(div);
@@ -2667,6 +2776,7 @@ const modelPicker = createModelPicker({
   center: $("#center"),
   onPick: () => {
     renderNewChatLlmContext();
+    renderNewChatThinking();
     promptEl.focus();
   },
 });
@@ -2683,6 +2793,7 @@ async function loadModels() {
   modelPickEl.title = payload.warning ? `The model the new chat starts on · ${payload.warning}` : "The model the new chat starts on";
   modelPickEl.hidden = false;
   renderNewChatLlmContext();
+  renderNewChatThinking();
 }
 // The picker's choice for a create request; nothing (the server's default)
 // while the list is not in.

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

@@ -4,17 +4,22 @@
 
 // The commands to offer while the composer holds one "/word" being typed
 // (no space or newline yet): the session's slash commands that start with
-// it, by name. The terminal UIs' own (local: /stats, /exit …) don't run here.
+// it, by name. A UI's own (local) one is offered only when its uis name
+// the web (/cut); the terminals' own (/stats, /exit …) don't run here.
 export function commandMatches(commands, text) {
   const typed = String(text || "");
   if (!/^\/\S*$/.test(typed)) return [];
   const needle = typed.toLowerCase();
   return (Array.isArray(commands) ? commands : [])
-    .filter((c) => c && !c.local && typeof c.name === "string" && c.name.startsWith("/"))
+    .filter((c) => c && runsInWeb(c) && typeof c.name === "string" && c.name.startsWith("/"))
     .filter((c) => c.name.toLowerCase().startsWith(needle))
     .sort((a, b) => a.name.localeCompare(b.name));
 }
 
+function runsInWeb(command) {
+  return !command.local || (Array.isArray(command.uis) && command.uis.includes("web"));
+}
+
 // What picking +name+ does to the composer: {text, send}. The name
 // completes with a space for its arguments; ⏎ on a name already typed in
 // full sends it as it is (⏎ on "/help" runs /help).