samagotchi 0.55.0 → 0.57.0

data/lib/samagotchi/thinking.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "config"
+require_relative "model_profile"
+require_relative "setting_explained"
 
 module Samagotchi
   # How much a model thinks: one level per model, host or run, mapped to each
@@ -38,21 +40,6 @@ module Samagotchi
     # The source a session's own level reads as.
     SESSION_SOURCE = "session"
 
-    # A level and where it came from (#explain): +source+ is "session",
-    # "--thinking", "SAMAGOTCHI_THINKING_LEVEL", "models: qwen",
-    # "hosts.work" or "thinking.level", nil for the default; +own+ is the
-    # session's own level, nil without one. What /thinking, /model,
-    # /stats, the snapshots and the web read.
-    Explained = Data.define(:level, :source, :own) do
-      # "low (session)", "default" with no source.
-      def label = source ? "#{level} (#{source})" : level.to_s
-
-      # The plain form the snapshots, the worker's command_ran event and
-      # the web read.
-      # @return [Hash] symbol keys
-      def summary = { level: level.to_s, source: source, own: own&.to_s }
-    end
-
     module_function
 
     # A session's own level from its file or a command word: :off, :low,
@@ -113,11 +100,11 @@ module Samagotchi
       [DEFAULT, nil]
     end
 
-    # #resolve, as an Explained with the session's own level beside it.
-    # @return [Explained]
+    # #resolve, as a SettingExplained with the session's own level beside it.
+    # @return [SettingExplained]
     def explain(target, names:, models: nil, session: nil)
       level, source = resolve(target, names: names, models: models, session: session)
-      Explained.new(level: level, source: source, own: session)
+      SettingExplained.new(level: level, source: source, own: session)
     end
 
     # thinking.level as a level and its origin (:cli, :env, :file), or nil.
@@ -133,17 +120,25 @@ module Samagotchi
     end
 
     # What a level change costs the prompt cache on +target+ (/thinking's
-    # note; a confirm step may ask before the costly ones):
-    #   :full      the native Gemma 4 prompt starts with <|think|>, so the
-    #              whole prompt is read again;
-    #   :provider  a chat host gets other request fields: a local llama.cpp
-    #              or Splash server keeps its cache, a hosted API may not;
-    #   :tail      native Qwen and the rest: only the tail changes.
+    # note; CacheConfirm asks before the costly ones):
+    #   :full      Gemma 4's prompt starts with <|think|> (the native
+    #              profile, or a local chat server whose model name says
+    #              gemma: its template writes the same token), so the whole
+    #              prompt is read again;
+    #   :provider  a remote chat host gets other request fields: Claude's
+    #              message breakpoints and OpenAI's prefix cache are lost;
+    #   :tail      native Qwen, a local chat server's Qwen and the rest:
+    #              only the tail changes (llama.cpp and Splash keep the rest).
     # @param target [HostRegistry::ModelTarget]
     # @param profile [String, nil] the native prompt profile's name
     # @return [Symbol]
     def cache_cost(target, profile: nil)
-      return :provider if target.entry&.chat?
+      entry = target.entry
+      if entry&.chat?
+        return :provider if entry.remote?
+
+        return ModelProfile.inferred_profile_name(target.bare_model) == "gemma4" ? :full : :tail
+      end
 
       profile == "gemma4" ? :full : :tail
     end

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/tool_runner.rb

@@ -28,7 +28,8 @@ module Samagotchi
 
     # @param kernel [KernelLoop] read lazily: Engine sets its hooks after
     #   the kernel is built.
-    # @param clock [#call] monotonic seconds, for the approval wait
+    # @param clock [#call] monotonic seconds, for the approval wait and the
+    #   dispatch time (after_tool_call's elapsed_ms)
     def initialize(kernel, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       @kernel = kernel
       @clock = clock
@@ -71,7 +72,14 @@ module Samagotchi
       end
       before = verdict.deny? ? NOT_AN_EDIT : file_before(call)
       index_before = before.equal?(NOT_AN_EDIT) ? nil : memory_index_size(call)
-      result = verdict.deny? ? denied(call, verdict) : dispatch(call)
+      elapsed_ms = nil
+      if verdict.deny?
+        result = denied(call, verdict)
+      else
+        dispatched_at = @clock.call
+        result = dispatch(call)
+        elapsed_ms = ((@clock.call - dispatched_at) * 1000).round
+      end
       diff = file_change(call, before)
       if diff && refresh_memory_index(call)
         result = with_index_note(result, index_before, call)
@@ -80,6 +88,9 @@ module Samagotchi
       result, images = attach_images(call, result) if result[:images]
 
       output = scrub(result[:output].to_s)
+      # The tool's own text, for after_tool_call: no "[tool]" lead, no
+      # ran-as line, no cap.
+      tool_text = output.sub(/\A\[#{Regexp.escape(call[:name].to_s)}\](?:\n| )/, "")
       # The gate may have replaced the call (known-names corrects a near
       # miss): one leading line tells the model what actually ran.
       if (changed = changed_call_line(original, call))
@@ -104,7 +115,7 @@ module Samagotchi
       # After the completed event: a hook's card (check-in, skills) prints
       # under the call's tool row, not before it.
       fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
-                               status: status || "error" })
+                               status: status || "error", call: call.dup, elapsed_ms: elapsed_ms, result: tool_text })
 
       run = { output: output, capped_output: capped, truncated: truncated, activity: result[:activity] }
       run[:images] = images if images&.any?

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/execute.rb

@@ -24,6 +24,8 @@ module Samagotchi
       NOT_RUN_ON_STOP = "Error: not run, the user stopped the turn"
       # The first words of a command the user's Stop killed.
       STOPPED_BY_USER = "Error: command stopped by the user"
+      # The first words of a command killed at the limit (hooks match on it).
+      TIMEOUT_PREFIX = "Error: command timed out after"
       TIMEOUT_HINT = "(killed at the limit; for a long command use task_create, then task_wait)"
       # How long the output may stay open once the shell has exited: a
       # `server &` child keeps the pipes, and the read would never end.
@@ -68,7 +70,7 @@ module Samagotchi
       rescue CommandTimedOut => e
         # Keep the "Error:" first line (callers classify on it), say how to run
         # a long command, and return whatever it printed before it was killed.
-        stopped_result("Error: command timed out after #{timeout_sec}s\n#{TIMEOUT_HINT}", e)
+        stopped_result("#{TIMEOUT_PREFIX} #{timeout_sec}s\n#{TIMEOUT_HINT}", e)
       rescue CommandCancelled => e
         stopped_result("#{STOPPED_BY_USER} after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
       rescue StandardError => e
@@ -189,7 +191,6 @@ module Samagotchi
       def self.timeout_seconds
         OutputGuardrails.config_positive_int("execute.timeout_sec", TIMEOUT_SEC)
       end
-      private_class_method :timeout_seconds
 
       # Resolves the working directory for the child process. An empty/absent
       # cwd defaults to the project root (Dir.pwd), mirroring task_runtime.

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.57.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.
@@ -689,10 +706,12 @@ 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 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.
+      # folder, on its model and with its own setup (SessionSetup: llm_context,
+      # thinking and reasoning_history levels), so dir, model, llm_context and
+      # thinking are refused beside it (a create takes no reasoning_history).
+      # 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)
         given = body["continues"]
         unless given.is_a?(String) && !given.strip.empty?
@@ -820,6 +839,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";
@@ -65,9 +66,10 @@ import {
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
 import { installRefClicks, setRefKinds } from "./refs.js";
+import { linkRefs, touchedFiles } from "./ref_scan.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 +136,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 +774,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);
@@ -826,6 +838,7 @@ function renderHistory(items) {
   }
   if (typeof items[0] === "object" && items[0].role) {
     historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsHtml(selected, images) }));
+    linkTextRefs();
   } else {
     historyEl.innerHTML = items.map((c) => `<div class="bubble output">${escapeHtml(c)}</div>`).join("");
   }
@@ -890,20 +903,34 @@ async function readTurnEnd() {
   } catch(_){}
 }
 
+// The turn's answer as its rendered markdown, once it is final (the
+// turn-end read, an answer_display re-read); then its refs.
 function applyFinalMarkdown(messages) {
   const message = [...messages].reverse().find(
     (item) => item?.role === "assistant" && typeof item.html === "string",
   );
-  if (!message) return;
-
-  const bubble = findInTurnRoots(".bubble.output")
+  const bubble = message && findInTurnRoots(".bubble.output")
     .reverse()
     .find((item) => showsAnswer(item, message, normalize));
-  if (!bubble) return;
-
-  bubble.classList.add("markdown");
-  bubble.setAttribute(COPY_SOURCE_ATTR, copySource(message));
-  bubble.innerHTML = message.html;
+  if (bubble) {
+    bubble.classList.add("markdown");
+    bubble.setAttribute(COPY_SOURCE_ATTR, copySource(message));
+    bubble.innerHTML = message.html;
+  }
+  linkTextRefs();
+}
+
+// The `path:line` refs in the answers' and closed steps' texts that name a
+// file the session's rows (and cards) touched, on this page (ref_scan.js).
+// Not mid-stream: at a turn's end and after a reload's render. A ref
+// already made stays as it is.
+function linkTextRefs() {
+  const roots = turnRoots();
+  const touched = touchedFiles(roots);
+  if (!touched.size) return;
+  for (const root of roots) {
+    for (const el of root.querySelectorAll(".bubble.output, .gen:not(.live) > .gen-text")) linkRefs(el, touched, current.dir);
+  }
 }
 
 function seedSeenFromDom() {
@@ -1429,6 +1456,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 +1624,7 @@ const streamHandlers = createStreamHandlers({
   contextChips,
   llmContextControl,
   thinkingControl,
+  reasoningHistoryControl,
   sentIds,
   earlyRestores,
   stream: {
@@ -2284,6 +2313,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;
     }
   }