samagotchi 0.25.0 → 0.26.0

data/lib/samagotchi/bundles/loop-guard/plugin.rb

@@ -77,7 +77,18 @@ class ThinkingWatch
   MAX_DISTINCT = 5000
   SPLIT = /(?<=[.!?])\s+|\n+/
 
-  Loop = Struct.new(:period, :times, :sentences, :chars, keyword_init: true)
+  # +span+: the sentences a loop that isn't a cycle (the short run, the
+  # window) was seen in, +period+ the different ones among them; nil for a
+  # cycle of +period+ sentences seen +times+ times.
+  Loop = Struct.new(:period, :times, :sentences, :chars, :span, keyword_init: true) do
+    # "one sentence ×8", "3 sentences ×3", "12 different sentences in 48".
+    def describe
+      return "one sentence ×#{times}" if period == 1
+      return "#{period} sentences ×#{times}" unless span
+
+      "#{period} different sentences in #{span}"
+    end
+  end
   Sentence = Struct.new(:text, :words, :bigrams, :key, :length, keyword_init: true)
 
   attr_reader :thinking_chars
@@ -197,7 +208,8 @@ class ThinkingWatch
 
     texts = @recent.to_h # key => its last text
     top = @recent_counts.sort_by { |_key, n| -n }.first(3).map { |key, _n| texts[key] }
-    Loop.new(period: @recent_counts.size, times: @window_sentences / @recent_counts.size, sentences: top, chars: nil)
+    Loop.new(period: @recent_counts.size, times: @window_sentences / @recent_counts.size, sentences: top, chars: nil,
+             span: @window_sentences)
   end
 
   def short_loop(text, words)
@@ -216,7 +228,8 @@ class ThinkingWatch
     distinct = @short_window.uniq(&:first)
     return nil if distinct.length > @short_distinct
 
-    Loop.new(period: distinct.length, times: @short_count / distinct.length, sentences: distinct.first(3).map(&:last), chars: nil)
+    Loop.new(period: distinct.length, times: @short_count / distinct.length, sentences: distinct.first(3).map(&:last), chars: nil,
+             span: @short_window.length)
   end
 
   def count(key)
@@ -307,8 +320,7 @@ class Plugin
     return unless found
 
     @watch_done = true
-    what = "#{found.period == 1 ? "one sentence" : "#{found.period} sentences"} ×#{found.times}, " \
-           "#{(@watch.thinking_chars / 1000.0).round}k chars, #{(event[:elapsed_ms].to_i / 1000.0).round} s"
+    what = "#{found.describe}, #{(@watch.thinking_chars / 1000.0).round}k chars, #{(event[:elapsed_ms].to_i / 1000.0).round} s"
     # The notices quote the loop's sentences on one line (a short cycle
     # whole), as the stop card does.
     quoted = "\"#{cut(found.sentences.first(3).join(" ").gsub(/\s+/, " "))}\", #{what}"

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.25.0
+version: 0.26.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/cancellation_controller.rb

@@ -54,6 +54,14 @@ module Samagotchi
       @mutex.synchronize { @detail }
     end
 
+    # Who stopped it when a hook did: the detail's +by+ (the bundle, or the
+    # hook's label); nil for any other cancel.
+    def stopped_by
+      reason, detail = @mutex.synchronize { [@reason, @detail] }
+      by = detail[:by].to_s if reason == :hook && detail.is_a?(Hash)
+      by unless by.nil? || by.empty?
+    end
+
     # Yields a child controller for one generation: it is cancelled when
     # this one is, and #cancel_generation! cancels it alone. Gone after the
     # block.

data/lib/samagotchi/client.rb

@@ -148,6 +148,9 @@ module Samagotchi
         value.empty? ? nil : value
       end
 
+      # llama.cpp's own API: slots (`id_slot`), `cache_prompt`, /props.
+      def native? = @name == :llama_cpp
+
       private
 
       def openai_compatible?
@@ -243,11 +246,15 @@ module Samagotchi
     #   ImagePlan::NATIVE_PLACEHOLDER in the prompt (llama.cpp only)
     # @param sampling    [Hash]          request fields to add (SamplingSettings):
     #   temperature, penalties, …; they can't replace the fields above
+    # @param slot        [Integer, nil]  llama.cpp only: the slot (`id_slot`)
+    #   this request runs on. PromptWarmup's pin, and only while a warm-up
+    #   still runs there: a request pinned to a slot the server has since
+    #   cleared skips its prompt cache and prefills everything again
     # @return [String] the generated text
     def complete(prompt, stop: [], n_predict: nil, model: nil, on_chunk: nil, cancel_controller: nil, on_retry: nil,
-                 images: [], sampling: {})
+                 images: [], sampling: {}, slot: nil)
       images = Array(images)
-      request = { stop: stop, n_predict: n_predict, model: model, sampling: sampling }
+      request = { stop: stop, n_predict: n_predict, model: model, sampling: sampling, slot: slot }
       return stream_completion(LLM::Utf8Scrub.call(prompt), request, on_chunk, cancel_controller, on_retry) if images.empty?
 
       # The media marker is random per server process: a restart between the
@@ -269,6 +276,41 @@ module Samagotchi
 
     OPENAI_API_HINT = "does this host speak the OpenAI API? set `api: openai` on it"
 
+    # What a warm-up (#warm_up) did: the slot it ran on and the server's
+    # counts (tokens reused from the cache, tokens prefilled, prefill ms).
+    Warmup = Data.define(:slot, :cache_n, :prompt_n, :prompt_ms)
+
+    # Prefill +prompt+ and keep it in the server's cache, so the next
+    # request that starts with it only prefills what follows (PromptWarmup:
+    # the turn-end warm-up). llama.cpp's native /completion only; nil on
+    # any other transport. One non-streamed request generating one token
+    # (n_predict 0 does the same on current builds, 1 on every one): no
+    # retries, no first-token limit, no stream events. Errors are raised.
+    # @param slot [Integer, nil] the slot to run on (`id_slot`): the one the
+    #   last request used, which still holds its state
+    # @param images [Array<String>] as #complete's
+    # @return [Warmup, nil]
+    def warm_up(prompt, model: nil, slot: nil, images: [])
+      return nil unless @transport.native?
+
+      images = Array(images)
+      text = LLM::Utf8Scrub.call(images.empty? ? prompt : prompt.gsub(ImagePlan::NATIVE_PLACEHOLDER, media_marker!(model)))
+      payload = { prompt: images.empty? ? text : { prompt_string: text, multimodal_data: images },
+                  n_predict: 1, cache_prompt: true, stream: false }
+      payload[:id_slot] = slot if slot.is_a?(Integer)
+      model_name = @transport.model_for_payload(model)
+      payload[:model] = model_name if model_name
+      uri = completion_uri
+      request = Net::HTTP::Post.new(uri)
+      request["Content-Type"] = "application/json"
+      request.body = payload.to_json
+      response = @http.fetch(uri, request, retries: false, log_fields: { model: model, purpose: "warmup" })
+      body = JSON.parse(response.body.to_s)
+      timings = body["timings"].is_a?(Hash) ? body["timings"] : {}
+      Warmup.new(slot: body["id_slot"], cache_n: timings["cache_n"], prompt_n: timings["prompt_n"],
+                 prompt_ms: timings["prompt_ms"]&.round)
+    end
+
     private def stream_completion(prompt, fields, on_chunk, cancel_controller, on_retry)
       uri = completion_uri
       request = Net::HTTP::Post.new(uri)
@@ -456,11 +498,19 @@ module Samagotchi
       URI("#{@scheme}://#{@host}:#{@port}#{@transport.completion_path}")
     end
 
-    def completion_payload(prompt, stop:, n_predict:, model:, sampling: {})
+    def completion_payload(prompt, stop:, n_predict:, model:, sampling: {}, slot: nil)
       payload = { prompt: prompt, stop: stop, stream: true }
+      # A non-positive cap is dropped, which leaves the length to the server
+      # (unbounded): 0 here never means "only process the prompt". The
+      # turn-end warm-up (#warm_up) sends its own payload for that reason.
       payload[@transport.token_limit_key] = n_predict if n_predict && n_predict.to_i.positive?
       model_name = @transport.model_for_payload(model)
       payload[:model] = model_name if model_name
+      if @transport.native?
+        # llama.cpp's default today, sent anyway: chi's next turn relies on it.
+        payload[:cache_prompt] = true
+        payload[:id_slot] = slot if slot.is_a?(Integer)
+      end
       sendable_sampling(sampling).merge(payload)
     end
 

data/lib/samagotchi/config.rb

@@ -138,6 +138,11 @@ module Samagotchi
       Entry.new(key: "default.max_tokens",       yaml_path: %w[default max_tokens],       type: :integer, default: nil,              expose: %i[env config cli]),
       Entry.new(key: "max_tool_output_chars",    yaml_path: %w[max_tool_output_chars],    type: :integer, default: 10_000,          expose: %i[env config cli]),
 
+      # The turn-end warm-up (PromptWarmup): auto prefills the next turn's
+      # prompt on a local llama.cpp host while the user reads; off never
+      # does. A :string, since YAML reads an unquoted off as false.
+      Entry.new(key: "cache.warmup",             yaml_path: %w[cache warmup],             type: :string, default: "auto",           expose: %i[env config]),
+
       Entry.new(key: "retry.max",                yaml_path: %w[retry max],                type: :integer, default: 5,               expose: %i[env config cli]),
       Entry.new(key: "retry.base_delay",         yaml_path: %w[retry base_delay],         type: :float,   default: 0.5,             expose: %i[env config cli]),
       Entry.new(key: "retry.max_delay",          yaml_path: %w[retry max_delay],          type: :float,   default: 8.0,             expose: %i[env config cli]),
@@ -661,9 +666,11 @@ module Samagotchi
     end
 
     # Request keys chi sets itself; a `sampling:` map can't override them.
-    # (Length caps would need their own semantics.)
+    # (Length caps would need their own semantics.) `id_slot` too: pinning
+    # every request to one llama.cpp slot makes a request after an idle
+    # gap skip the server's prompt cache (measured: 0.5 s → 12 s).
     SAMPLING_RESERVED_KEYS = %w[model messages prompt stream stream_options tools tool_choice stop n_predict
-                                max_tokens n parallel_tool_calls response_format cache_prompt].freeze
+                                max_tokens n parallel_tool_calls response_format cache_prompt id_slot].freeze
 
     # A `sampling:` setting (hosts entry or models: entry): request parameters
     # passed through to the provider as written (keys symbolized, nested maps

data/lib/samagotchi/engine.rb

@@ -64,6 +64,7 @@ require_relative "question_desk"
 require_relative "relay_desk"
 require_relative "guardrail_wiring"
 require_relative "plugin_tasks"
+require_relative "prompt_warmup"
 
 module Samagotchi
   # Engine owns the core agent logic: system prompt construction, tool
@@ -242,6 +243,9 @@ module Samagotchi
       # list_sessions and send_note speak for whichever session runs now.
       @kernel.peers = PeerView.new(self)
       @kernel.guardrail_gate = @guardrail_wiring.gate
+      # The turn-end warm-up; the kernel asks it for a slot pin per request.
+      @prompt_warmup = PromptWarmup.new
+      @kernel.warmup = @prompt_warmup
       # What a hook can do beyond reading its event (event[:notify],
       # event[:ask_user], event[:stop_turn]): the Engine's routes to the UIs.
       @hooks.runtime = hook_runtime
@@ -1615,6 +1619,7 @@ module Samagotchi
                                 pending_input: pending_input)
         publish_used_memories(session, on_event)
         complete_turn(turn, result)
+        warm_up_next_turn(turn, result)
         result
       rescue Interrupt
         # After the end event (in the after_turn/session_end hooks) the
@@ -1751,13 +1756,7 @@ module Samagotchi
     # Who stopped a turn a hook stopped or cut (the controller's detail: the
     # bundle, or the hook's label), for the UIs' "stopped by loop-guard";
     # nil for any other cancel.
-    def cancelled_by(turn)
-      return nil unless turn.controller.reason == :hook
-
-      detail = turn.controller.detail
-      by = detail[:by].to_s if detail.is_a?(Hash)
-      by unless by.nil? || by.empty?
-    end
+    def cancelled_by(turn) = turn.controller.stopped_by
     private :cancelled_by
 
     # The turn's settings for the kernel (LLM::TurnSettings): vision,
@@ -1775,6 +1774,50 @@ module Samagotchi
     end
     private :turn_settings
 
+    # @return [PromptWarmup] the turn-end warm-up (specs, measurements)
+    attr_reader :prompt_warmup
+
+    # A caller's check that the next turn starts at once (input queued for
+    # it: a worker's inbox) or that none follows (a one-shot run): no
+    # warm-up then. nil: neither.
+    attr_writer :next_turn_waiting
+
+    # After a completed turn, prefill the next turn's prompt up to its user
+    # message while the user reads (PromptWarmup, cache.warmup). Only on a
+    # local llama.cpp host on the native loop, and not when the next turn's
+    # start differs anyway or starts at once: a reminder due, a continue
+    # offer (the turn ran out of steps), a carried steer or queued input.
+    # Never fails the turn.
+    def warm_up_next_turn(turn, result)
+      return if result.canceled? || result.resumable?
+
+      target = @host_registry.resolve(@effective_model_name)
+      client = target.client
+      return unless warmup_target?(target, client)
+      return if reminders_due? || @turn_state.carried_steers? || @next_turn_waiting&.call
+
+      messages = ContextNote.with_system_head(turn.session.messages.dup, { role: "system", content: system_prompt(target) })
+      prompt, images = @kernel.warmup_prompt(messages)
+      return unless prompt
+
+      @prompt_warmup.start(client: client, prompt: prompt, model: @kernel.turn_settings.model_name,
+                           slot: @kernel.last_slot, images: images)
+    rescue StandardError => e
+      Log.warn(:model, "warmup_skipped", error: e.class.name, msg: e.message.to_s[0, 200])
+    end
+    private :warm_up_next_turn
+
+    # Never a paid or remote host (cache.warmup auto means local only), nor
+    # the chat loop (Splash keeps its own cache; llama.cpp's chat path is
+    # not measured), nor a non-llama.cpp transport.
+    def warmup_target?(target, client)
+      return false if target.entry.chat? || target.entry.remote?
+      return false unless client.respond_to?(:warm_up) && client.respond_to?(:transport) && client.transport.native?
+
+      PromptWarmup.enabled?
+    end
+    private :warmup_target?
+
     # The messages the turn sends: the history under the system head, due
     # reminders, the prompt. turn.messages is set first and grown in place,
     # so a Ctrl-C or a failure meanwhile keeps what is there.

data/lib/samagotchi/kernel_loop.rb

@@ -156,6 +156,13 @@ module Samagotchi
     # Tools::Peers (or the Engine's live view of it): the session
     # list_sessions and send_note speak for; nil outside a session.
     attr_accessor :peers
+    # The Engine's PromptWarmup: a request asks it for a slot pin
+    # (#take_pin) while the turn-end warm-up still runs; nil: never pinned.
+    attr_accessor :warmup
+    # @return [Integer, nil] the llama.cpp slot (`id_slot`) the last
+    #   request of the last run streamed from; nil when the server named
+    #   none (other transports) or no request was made
+    attr_reader :last_slot
 
     # Run the conversation loop and return the final model response plus
     # resumable conversation state when execution stops at max_iterations.
@@ -177,6 +184,7 @@ module Samagotchi
     # @return [LLM::ModelResult] final visible response with continuation metadata
     def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
       @turn_settings = @turn_settings.with(model_name: completion_model_name(model_name))
+      @last_slot = nil
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
                                   pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars))
 
@@ -186,7 +194,8 @@ module Samagotchi
         return outcome if outcome.is_a?(LLM::ModelResult)
         break if outcome == :answer
       rescue Client::RequestCancelled => e
-        emit(turn, type: :generation_cancelled, iteration: turn.iteration, reason: e.reason)
+        emit(turn, type: :generation_cancelled, iteration: turn.iteration, reason: e.reason,
+                   stopped_by: turn.cancel_controller&.stopped_by)
         return cancelled_result(turn.conversation, tool_activity: turn.tool_activity, reason: e.reason,
                                                    partial_assistant_text: turn.buffer)
       end
@@ -354,6 +363,8 @@ module Samagotchi
       # llama.cpp names the loaded model in the stream's last payload.
       named = chunk[:payload]["model"] if chunk[:payload].is_a?(Hash)
       generation.served_model = named if named.is_a?(String) && !named.strip.empty?
+      slot = chunk[:payload]["id_slot"] if chunk[:payload].is_a?(Hash)
+      @last_slot = slot if slot.is_a?(Integer)
       generation.finish_reason = chunk[:finish_reason] if chunk[:finish_reason]
       split = stream_splitter.feed(chunk[:content])
       turn.buffer << split[:text]
@@ -433,7 +444,7 @@ module Samagotchi
       end
       turn.empty_retry.drop_nudge!(turn.conversation)
       turn.cancel_controller.cancel!(:hook, cut)
-      emit(turn, type: :generation_cancelled, iteration: turn.iteration, reason: :hook)
+      emit(turn, type: :generation_cancelled, iteration: turn.iteration, reason: :hook, stopped_by: cut[:by])
       cancelled_result(turn.conversation, tool_activity: turn.tool_activity, reason: :hook, partial_assistant_text: "")
     end
 
@@ -566,7 +577,11 @@ module Samagotchi
     # One request, cancelled by +generation_controller+ (the turn's child)
     # when there is one.
     def request_generation(prompt, generation_controller:, cancel_controller:, **)
-      @client.complete(prompt, **complete_kwargs(cancel_controller: generation_controller || cancel_controller, **))
+      kwargs = complete_kwargs(cancel_controller: generation_controller || cancel_controller, **)
+      # Behind a turn-end warm-up still running on its slot (PromptWarmup).
+      slot = @warmup&.take_pin(@client)
+      kwargs[:slot] = slot if slot
+      @client.complete(prompt, **kwargs)
     end
 
     # Yields the turn controller's child for one generation (nil without a
@@ -644,6 +659,22 @@ module Samagotchi
 
     public
 
+    # The next turn's prompt up to where its user message starts, for the
+    # turn-end warm-up (PromptWarmup): +messages+ as the next turn sends
+    # them before its prompt (the history under the system head), formatted
+    # as #run formats them, with a stand-in user message cut off at its
+    # opener. Returns [prompt, images], or nil when the cut isn't found.
+    def warmup_prompt(messages)
+      conversation = prepare_conversation(messages) << { role: "user", content: WARMUP_CUT }
+      prompt, images = Prompt.format_with_images(conversation, profile: @profile, vision: @turn_settings.vision)
+      head = prompt[0, prompt.index(WARMUP_CUT) || 0]
+      cut = head.rindex(user_opener)
+      cut&.positive? ? [head[0, cut], images] : nil
+    end
+
+    WARMUP_CUT = "chi-warmup-cut"
+    private_constant :WARMUP_CUT
+
     # Public wrapper so other loops (e.g. the chat loop) can strip
     # per-profile thought blocks from finished model text without duplicating the
     # Gemma 4 / Qwen 3.6 logic. Mirrors the native loop's "strip before deciding
@@ -679,6 +710,11 @@ module Samagotchi
       parser.strip_thought(text)
     end
 
+    # What opens a user turn in the profile's format.
+    def user_opener
+      @profile.uses_role_prefixes? ? @profile.user_prefix : "#{@profile.turn_start}user\n"
+    end
+
     def sanitize_history(messages)
       messages.map do |m|
         if m[:role] == "model"

data/lib/samagotchi/llm/chat_loop.rb

@@ -595,7 +595,7 @@ module Samagotchi
         # The text streamed before the cancel stays, marked [interrupted],
         # as the native loop's salvage does.
         def canceled(iteration, reason, partial = "")
-          emit(type: :generation_cancelled, iteration: iteration, reason: reason)
+          emit(type: :generation_cancelled, iteration: iteration, reason: reason, stopped_by: @cancel_controller&.stopped_by)
           visible = @loop.strip_model_thought(partial.to_s).strip
           @conversation << { role: "model", content: "#{visible}\n[interrupted]", interrupted: true } unless visible.empty?
           conversation = @loop.plain(@conversation)

data/lib/samagotchi/llm/http.rb

@@ -36,9 +36,10 @@ module Samagotchi
         Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ETIMEDOUT
       ].freeze
 
-      # Requests of these purposes are the ones a turn waits on: INFO lines
-      # (and ERROR when they fail). Probes and model lists are DEBUG.
-      LOGGED_PURPOSES = %w[chat recap].freeze
+      # Requests of these purposes are the ones a turn waits on (or, for the
+      # turn-end warm-up, prepares the next one): INFO lines (and ERROR when
+      # they fail). Probes and model lists are DEBUG.
+      LOGGED_PURPOSES = %w[chat recap warmup].freeze
 
       # Exponential backoff: base_delay * 2^(attempt-1), capped at max_delay,
       # for up to +max+ retries (max + 1 attempts).
@@ -127,7 +128,7 @@ module Samagotchi
       # @raise [ProviderError] for an error status
       # @raise [FirstTokenTimeout] when nothing was shown in time
       # @param log_fields [Hash] what the log line says about the request
-      #   (model:, purpose: chat/recap/probe/models); never its body
+      #   (model:, purpose: chat/recap/warmup/probe/models); never its body
       def stream_lines(uri, request, cancel_controller: nil, on_retry: nil, on_network_error: nil, log_fields: {}, &on_line)
         identify(request)
         current = new_attempt_state(uri, request, log_fields, stream: true)

data/lib/samagotchi/prompt_warmup.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "log"
+
+module Samagotchi
+  # The turn-end warm-up (cache.warmup). After a turn, the next turn's prompt
+  # differs from the last request at its tail: the previous answer's
+  # thinking is stripped (Gemma's and Qwen's specs), so a hybrid model on
+  # llama.cpp prefills from a restore point well before the end, longer
+  # with every turn. The warm-up sends that prompt, up to where the new user
+  # turn starts, while the user reads, so the next turn prefills only its
+  # own message (measured on Ornith: 0.73 s -> 0.11 s; 417 -> 26 tokens).
+  #
+  # The slot rule (R4 spike, llama.cpp with its host-memory prompt cache):
+  # - the warm-up runs on the slot the turn's last request used, which still
+  #   holds its state (Client#warm_up, `id_slot`);
+  # - the next request is pinned to that slot only while the warm-up still
+  #   runs, so it queues behind it (0.6 s) instead of starting cold on
+  #   another slot (12 s);
+  # - once the warm-up is done, nothing is pinned: the server finds the
+  #   state itself, and pinning to a slot it has since cleared skips its
+  #   prompt cache (12 s again). #take_pin forgets the slot either way.
+  class PromptWarmup
+    MODES = %w[auto off].freeze
+
+    # Whether cache.warmup allows a warm-up (auto, the default; off, false,
+    # no or 0 turn it off; anything else warns once and is auto).
+    def self.enabled?
+      value = Config.get("cache.warmup").to_s.strip.downcase
+      return false if %w[off false no 0].include?(value)
+
+      unless value.empty? || value == "auto" || @warned
+        @warned = true
+        Log.warn(:config, "invalid_value", echo: "Warning: invalid value for cache.warmup: #{value.inspect} (allowed: auto, off) — using auto",
+                                           key: "cache.warmup")
+      end
+      true
+    rescue StandardError
+      true
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      # The pin (#take_pin forgets it) and the last warm-up's thread.
+      @state = nil
+      @thread = nil
+    end
+
+    # Start a warm-up of +prompt+ on +client+ in its own thread.
+    # @param slot [Integer, nil] the last request's slot (nil: unpinned, and
+    #   nothing to pin the next request to)
+    # @return [Thread]
+    def start(client:, prompt:, model:, slot:, images: [])
+      thread = Thread.new do
+        Thread.current.report_on_exception = false
+        result = client.warm_up(prompt, model: model, slot: slot, images: images)
+        Log.info(:model, "warmup", slot: result&.slot, cached: result&.cache_n, prefilled: result&.prompt_n,
+                                   prefill_ms: result&.prompt_ms, chars: prompt.length)
+        result
+      rescue StandardError => e
+        Log.warn(:model, "warmup_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+        nil
+      end
+      @mutex.synchronize do
+        @thread = thread
+        @state = { thread: thread, client: client, slot: slot }
+      end
+      thread
+    end
+
+    # The slot the next request on +client+ must run on: the warm-up's,
+    # while it still runs there; nil otherwise (done, failed, unpinned, or
+    # another host). Called once per request; the first call forgets the
+    # warm-up, so no later request is ever pinned.
+    def take_pin(client)
+      state = @mutex.synchronize { @state.tap { @state = nil } }
+      return nil unless state && state[:slot].is_a?(Integer) && state[:client].equal?(client)
+
+      state[:thread].alive? ? state[:slot] : nil
+    end
+
+    # Whether a warm-up is running (specs, measurements).
+    def running?
+      thread = @mutex.synchronize { @thread }
+      thread&.alive? || false
+    end
+
+    # Wait up to +timeout+ seconds for the running warm-up (specs).
+    def wait(timeout = nil)
+      thread = @mutex.synchronize { @thread }
+      thread&.join(timeout)
+    end
+  end
+end

data/lib/samagotchi/terminal_ui.rb

@@ -173,6 +173,8 @@ module Samagotchi
       # -p without --non-interactive drops into the REPL, which can answer
       # an approval; --non-interactive can't, so an approval there denies.
       @engine.interface = @non_interactive ? :non_interactive : :repl
+      # A --non-interactive run exits after its turn: no turn-end warm-up.
+      @engine.next_turn_waiting = -> { true } if @non_interactive
       @turn_flow = TurnFlow.new(engine: @engine)
       # A recap written while a continue offer waits says the turn stopped
       # unfinished. (Answering at the prompt is typing: activity already.)

data/lib/samagotchi/thinking_tails.rb

@@ -55,8 +55,9 @@ module Samagotchi
       when :generation_chunk then add(event[:thinking].to_s)
       when :generation_completed then completed(event)
       when :generation_cancelled
-        # A plugin's stop_turn mid-generation; a user's Stop is not kept.
-        keep(event, finish_reason: "cancelled", stopped_by: "hook") if event[:reason].to_s == "hook"
+        # A plugin's stop_turn mid-generation (the bundle that stopped it,
+        # "hook" when unknown); a user's Stop is not kept.
+        keep(event, finish_reason: "cancelled", stopped_by: (event[:stopped_by] || "hook").to_s) if event[:reason].to_s == "hook"
       end
     rescue StandardError
       nil

data/lib/samagotchi/tool_declarations.rb

@@ -28,7 +28,7 @@ module Samagotchi
             },
             description: {
               type: "string",
-              description: "Optional: what this command does, in a few words (what, not why)"
+              description: "What this command does, in a few words (what, not why). Shown to the user as the step's title, so include it on every call."
             },
             cwd: {
               type: "string",

data/lib/samagotchi/turn_note.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "model_profile"
+
 module Samagotchi
   # The one-line system note a turn leaves in the conversation when it ends
   # without an answer: failed before the model replied, cancelled, or over
@@ -19,6 +21,12 @@ module Samagotchi
     TASK_COMMAND_CHARS = 60
     RETRY_NUDGE = :retry_nudge
     EMPTY_ANSWER = :empty_answer
+    # An empty step's thinking kept on the marker: its tail, so a model
+    # that thought for minutes doesn't put megabytes in the session file.
+    STEP_CHARS = 20_000
+    # A step's native thinking starts with one of these; the cut keeps it,
+    # so the UIs still find the thinking (MessageParts).
+    THINK_OPENS = ["<think>", ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN].freeze
 
     module_function
 
@@ -75,16 +83,32 @@ module Samagotchi
     # UIs, which draw the turn's notice and steps from it after a reload:
     # +retries+ the empty-answer retries spent, +steps+ the empty
     # generations as model messages (their thinking; the loops keep them out
-    # of the conversation, where they'd be empty assistant turns). Never
+    # of the conversation, where they'd be empty assistant turns), each
+    # text cut to its last STEP_CHARS. Never
     # sent: the payload builders send a system message's content, and the
     # copies for hooks, plugins and the recap drop it (AnswerDisplay.strip).
     def empty(retries: 0, steps: [])
       marker = { retries: retries.to_i }
-      marker[:steps] = steps.map { |step| step.slice(:role, :content, :thinking) } unless steps.empty?
+      marker[:steps] = steps.map { |step| capped_step(step) } unless steps.empty?
       message("the previous turn ended with no visible answer (thinking only, or nothing). The user's last message is still unanswered.")
         .merge(EMPTY_ANSWER => marker)
     end
 
+    def capped_step(step)
+      step.slice(:role, :content, :thinking).to_h do |key, value|
+        [key, key == :role || !value.is_a?(String) ? value : tail_of(value)]
+      end
+    end
+
+    # The last STEP_CHARS of +text+ after a line saying how much was cut
+    # (and the thinking's opening tag when it had one); short text as is.
+    def tail_of(text)
+      return text if text.length <= STEP_CHARS
+
+      open = THINK_OPENS.find { |tag| text.start_with?(tag) }
+      "#{open}[… #{text.length - STEP_CHARS} earlier characters cut]\n#{text[-STEP_CHARS..]}"
+    end
+
     # The empty-answer marker of +entry+ (either key type), or nil.
     def empty_answer(entry)
       return nil unless note?(entry)

data/lib/samagotchi/turn_state.rb

@@ -133,6 +133,12 @@ module Samagotchi
       true
     end
 
+    # @return [Boolean] whether #steer_next_turn queued anything a turn has
+    #   yet to begin with
+    def carried_steers?
+      @lock.synchronize { !@carried_steers.empty? }
+    end
+
     # Drop what #steer_next_turn queued and no turn began with (a no-op
     # once #begin! took it).
     # @return [Array<Hash>] the steers dropped ({text:, source:})

data/lib/samagotchi/version.rb

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

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

@@ -20,8 +20,9 @@ export function rowHover(row) {
 //
 // A view with steps (CommandSteps) shows them in the command's place, its
 // leading cd as one more "in" tag, and a "raw" toggle (a checkbox, CSS
-// only, so a live and a reloaded row behave alike) that swaps the steps
-// for the command as written. The copy button copies the raw command
+// only, so a live and a reloaded row behave alike; beside the first step
+// when there's no "in" tag) that swaps the steps for the command as
+// written. The copy button copies the raw command
 // either way. A view without steps (the parser's fallback) is the raw
 // block alone: nothing hides the command.
 //
@@ -47,7 +48,9 @@ export function commandBlockHtml(view, title = null) {
     const cwd = where ? `<div class="activity-command-cwd">${where}</div>` : "";
     return `<div class="activity-command code-wrap">${desc}${cwd}${raw}${copyButtonHtml("code")}${cut}</div>`;
   }
-  const head = `<div class="activity-command-head"><span class="activity-command-cwd">${where}</span>` +
+  // No "in" tag: the toggle alone, floated beside the first step (an
+  // empty line for it would sit above the steps).
+  const head = (where ? `<div class="activity-command-head"><span class="activity-command-cwd">${where}</span>` : `<div class="activity-command-head bare">`) +
     `<label class="activity-command-raw" title="Show the command as written"><input type="checkbox">raw</label></div>`;
   return `<div class="activity-command code-wrap has-steps">${desc}${head}${stepsHtml(steps)}${raw}${copyButtonHtml("code")}${cut}</div>`;
 }