samagotchi 0.25.0 → 0.27.0

data/docs/plugins.md

@@ -860,8 +860,9 @@ What happens (`action: retry`, the default):
 1. The first loop in a turn: the generation is cut and the model asked
    again, with a hidden note that it was cut off. The user sees the loop's
    first sentence quoted,
-   `loop-guard> thinking repeats itself ("Wait, the count of the letter r…", 3 sentences ×3, 4k chars, 8 s): cut`,
-   and `↻ cut by loop-guard, asking again (1/1)`.
+   `loop-guard> thinking repeats itself ("Wait, the count of the letter r…", 3 sentences ×3, 4k chars, 8 s): cut`
+   (a short run or a window says how many different sentences it held:
+   "12 different sentences in 48"), and `↻ cut by loop-guard, asking again (1/1)`.
 2. If the retry loops too, the turn is stopped ("stopped the turn: …", "✕
    turn stopped by loop-guard") with a card that quotes the repeated
    sentences.

data/lib/samagotchi/bridge.rb

@@ -27,6 +27,8 @@ require_relative "version"
 require_relative "worker_sidecar"
 require_relative "relay_verifier"
 require_relative "relay_watcher"
+require_relative "tools/task_create"
+require_relative "tools/task_runtime"
 
 module Samagotchi
   # Bridge is an optional HTTP transport that lets an external web / desktop
@@ -461,7 +463,8 @@ module Samagotchi
     # sidecar (WorkerSidecar#features): a client checks a name here rather
     # than a version.
     # restart: POST /exit takes "restart": true (WorkerIdleExit#hold_for_restart).
-    FEATURES = ["restart"].freeze
+    # task_stop: POST tasks/stop (#handle_task_stop), the web's stop-task button.
+    FEATURES = %w[restart task_stop].freeze
 
     # The routes, by method and what follows /session/:id/: a handler takes
     # the session id and the request body and returns [headers, status, body].
@@ -477,6 +480,7 @@ module Samagotchi
       %w[POST recap] => :handle_recap,
       %w[POST relay] => :handle_relay,
       %w[POST relay/status] => :handle_relay_status,
+      %w[POST tasks/stop] => :handle_task_stop,
       %w[GET state] => :handle_state,
       %w[GET stats] => :handle_stats,
       %w[GET snapshot] => :handle_snapshot,
@@ -539,6 +543,38 @@ module Samagotchi
       end
     end
 
+    # POST /session/:id/tasks/stop {task_id}: stop a background task as the
+    # user (TaskRuntime.stop_task by: "user"); a task_wait on it returns, and
+    # the turn goes on. Only a task this conversation created: records in
+    # tmp/tasks are shared by every session in the cwd. Those are in the
+    # saved conversation, or, created in the running turn, only in the
+    # accumulator's task_create parts. 200 {status, stop_reason, task_id},
+    # 404 task_not_found, 409 not_running (it already ended), 400 no id.
+    # Answers once the task is gone: up to STOP_GRACE_SEC.
+    def handle_task_stop(_session_id, body)
+      parsed = parse_json(body)
+      task_id = (fetched(parsed, "task_id") if parsed.is_a?(Hash)).to_s.strip
+      return [{ "Allow" => "POST" }, 400, { error: "missing_fields", detail: "task_id required" }] if task_id.empty?
+      return [{}, 404, { error: "task_not_found", task_id: task_id }] unless own_task_ids.include?(task_id)
+
+      record, error = Tools::TaskRuntime.get_record(task_id)
+      return [{}, 404, { error: "task_not_found", task_id: task_id }] if error
+      return [{}, 409, { error: "not_running", status: record["status"], task_id: task_id }] unless record["status"] == "running"
+
+      Log.info(:bridge, "task_stop", task_id: task_id)
+      record, error = Tools::TaskRuntime.stop_task(task_id, by: "user")
+      return [{}, 500, { error: "bridge_error", detail: error }] if error
+
+      [{}, 200, { status: record["status"], stop_reason: record["stop_reason"], task_id: task_id }]
+    end
+
+    def own_task_ids
+      running = Array(@accumulator.current_turn&.dig(:parts)).filter_map do |part|
+        part[:output].to_s[/\A(?:\[task_create\]\n)?task_id: (\S+)/, 1] if part[:kind] == "tool" && part[:tool] == Tools::TaskCreate::NAME
+      end
+      Tools::TaskRuntime.created_ids_in(@engine.messages_checkpoint) | running
+    end
+
     # Answer the pending question. A past +deadline+ (see #handle_post_turn):
     # 408 deadline_passed, and the question stays open. An answer takes no
     # event hold, so it is checked right before it is recorded.

data/lib/samagotchi/bridge_client.rb

@@ -187,6 +187,15 @@ module Samagotchi
       post("cancel", { reason: reason }, read_body: true)
     end
 
+    # POST /session/:id/tasks/stop: stop a background task this session's
+    # conversation created, as the user (Bridge#handle_task_stop). 200 with
+    # its final status, 404 task_not_found, 409 not_running. Synchronous:
+    # the worker answers once the task is gone (up to its 3 s grace).
+    # @return [Response]
+    def stop_task(task_id)
+      post("tasks/stop", { task_id: task_id }, read_body: true)
+    end
+
     # How long the approval relay's calls wait for a reply: a parent's Stop
     # isn't held for READ_TIMEOUT by a child that doesn't answer.
     RELAY_TIMEOUT = 5

data/lib/samagotchi/bundles/loop-guard/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: loop-guard
-version: 0.3.3
+version: 0.3.4
 scope: system
 description: "Breaks loops: the same tool call with the same result again and again in one turn is denied with advice (after a few denies the turn stops with a card), and thinking that repeats itself while it streams is cut and the model asked again"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:8cf255cd1cc0846a759fcf70144af53bfc634c9d5c766981ce0ef5e476749e0a
+  sha256: sha256:a267a325aa134e3d9c57f41d9446c4385a6a1f6bee6267ef127880f8bc4d121f
 requires_chi: ">= 0.6.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/mcp/manifest.yml

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.4.2
+version: 0.4.3
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:d0491b038e7f111f9f8c629729a2b0525d573fd0b17d48ea8ec59c4a2b8b821b
+  sha256: sha256:079a42892f10822115235e1ced7ccd481f80c9ef54abb094f9a1c599bb03e8e2
 requires_chi: ">= 0.8.0"

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -752,7 +752,8 @@ class Plugin
 
     @servers.map do |server|
       head = "**#{server.name}**: #{state_text(server)}"
-      tools = server.tools.map { |tool| tool["chi_name"] }.compact
+      # Sorted: a server lists its tools in its own (often grouped) order.
+      tools = server.tools.map { |tool| tool["chi_name"] }.compact.sort
       tools.empty? ? head : "#{head}\n#{tools.map { |t| "- `#{t}`" }.join("\n")}"
     end.join("\n\n")
   end

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

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.25.0
+version: 0.27.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/log.rb

@@ -23,6 +23,8 @@ module Samagotchi
   # (once, until Config.reload!). While that runs (Config can warn itself)
   # records only echo. Nothing here raises into the caller: a record that
   # can't be formatted is dropped, an unwritable file pauses (DebugLog).
+  # The one exception is strict mode (SAMAGOTCHI_LOG_STRICT=1, the spec
+  # suite): an unknown tag or a malformed event raises, whatever the level.
   module Log
     LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }.freeze
     DEFAULT_LEVEL = :info
@@ -39,6 +41,7 @@ module Samagotchi
     @state = nil
     @resolving = false
     @session_id = nil
+    @strict = ENV["SAMAGOTCHI_LOG_STRICT"] == "1"
 
     class << self
       # @param path [String, nil, :auto] the file; :auto → LogPath.resolve
@@ -72,6 +75,9 @@ module Samagotchi
       # carry its first SID_LENGTH chars unless they pass their own sid:.
       attr_accessor :session_id
 
+      # Raise on an unknown tag or a bad event instead of dropping the record.
+      attr_accessor :strict
+
       def debug(tag, event, **kw) = log(:debug, tag, event, **kw)
       def info(tag, event, **kw) = log(:info, tag, event, **kw)
       def warn(tag, event, **kw) = log(:warn, tag, event, **kw)
@@ -96,7 +102,19 @@ module Samagotchi
         resolved_state&.dig(:writer)&.path
       end
 
-      def log(level, tag, event, payload: nil, sid: nil, echo: nil, **fields)
+      def log(level, tag, event, **kw)
+        check_names!(tag, event) if strict
+        write_record(level, tag, event, **kw)
+      end
+
+      private
+
+      def check_names!(tag, event)
+        raise ArgumentError, "unknown log tag #{tag}" unless LogLine::TAGS.include?(tag.to_s)
+        raise ArgumentError, "bad log event #{event}" unless event.to_s.match?(LogLine::SLUG)
+      end
+
+      def write_record(level, tag, event, payload: nil, sid: nil, echo: nil, **fields)
         options = @options
         echo_to_stderr(echo) if echo && options.fetch(:stderr, true)
         state = resolved_state
@@ -113,8 +131,6 @@ module Samagotchi
         nil
       end
 
-      private
-
       def build(level, tag, event, payload:, sid:, fields:)
         tag = tag.to_s
         event = event.to_s