samagotchi 0.17.0 → 0.18.1

data/lib/samagotchi/client.rb

@@ -31,12 +31,39 @@ module Samagotchi
     CONTEXT_WINDOW_PROBE_READ_TIMEOUT = 2
     # Seconds a probe that got no answer (refused, timed out) is remembered:
     # a down or hung server then costs one probe per window, not one per
-    # generation, and a new turn doesn't ask again at once.
+    # generation, and a new turn doesn't ask again at once. A request to the
+    # host that succeeds drops the remembered failure (see
+    # #clear_props_failures!).
     PROPS_FAILURE_TTL = 30
 
     DEFAULT_TRANSPORT = :llama_cpp
     VALID_TRANSPORTS = %i[llama_cpp mlx omlx].freeze
 
+    # One /props cache per host per process. A host has more than one Client
+    # in a run (the registry's, a rebuilt HostRegistry's, the Engines of a
+    # TUI and a spec): with a cache each, every one of them asks /props for
+    # the same server. Keyed by the host's base URL (scheme://host:port), so
+    # two Clients of the same server share the answers their turns read.
+    # Entries live for the process: they are the same small hash per host
+    # (answers by model, failures by model with their timestamps).
+    @props_store = {}
+    @props_store_mutex = Mutex.new
+
+    class << self
+      # The shared props entry for a host's base URL:
+      # { answers: { model => ServerProps }, failures: { model => [props, at] },
+      #   mutex: Mutex }. The caller may hold the entry's own mutex.
+      def props_entry(base_url)
+        @props_store_mutex.synchronize { @props_store[base_url] ||= { answers: {}, failures: {}, mutex: Mutex.new } }
+      end
+
+      # Forget every host's answers and failures. Specs call it per example
+      # (the store outlives one); nothing in a run does.
+      def reset_props_store!
+        @props_store_mutex.synchronize { @props_store.clear }
+      end
+    end
+
     # Wire-format strategy for one server transport. `Client` keeps the
     # transport-agnostic request/retry/stream loop; everything that differs
     # between llama.cpp's native API and the OpenAI-compatible servers
@@ -175,9 +202,13 @@ module Samagotchi
       @open_timeout  = Samagotchi::Config.positive_seconds("server.open_timeout", open_timeout)
       @read_timeout  = Samagotchi::Config.positive_seconds("server.read_timeout", read_timeout)
       @transport = build_transport(resolve_transport(transport))
-      @props_cache = {}
-      @props_failures = {}
-      @props_mutex = Mutex.new
+      # This host's process-wide /props entry (see self.props_entry): its
+      # answers and failures are shared with every other Client of the same
+      # server.
+      @props_entry = self.class.props_entry("#{@scheme}://#{@host}:#{@port}")
+      @props_cache = @props_entry[:answers]
+      @props_failures = @props_entry[:failures]
+      @props_mutex = @props_entry[:mutex]
       @first_token_timeout = first_token_timeout
       @host_name = name
       @label = name.to_s.empty? ? @transport.label : name.to_s
@@ -270,6 +301,10 @@ module Samagotchi
         chunk[:finish_reason] = finish_reason if finish_reason
         on_chunk.call(**chunk)
       end
+      # The host answered: a /props probe that failed while it was down (or
+      # loading) is no longer true, so the next turn asks it again instead
+      # of reusing the failure for the rest of its PROPS_FAILURE_TTL.
+      clear_props_failures!
       result
     rescue LLM::BadRequest => e
       raise unless e.status == 404 && @transport.name == :llama_cpp
@@ -293,6 +328,7 @@ module Samagotchi
     def list_models
       uri = URI("#{@scheme}://#{@host}:#{@port}#{@transport.models_path}")
       response = @http.fetch(uri, Net::HTTP::Get.new(uri), log_fields: { purpose: "models" })
+      clear_props_failures!
       parsed = JSON.parse(response.body.to_s)
       parsed.fetch("data", parsed)
     rescue LLM::ProviderError
@@ -309,7 +345,9 @@ module Samagotchi
     # Whatever the server answers (a non-200 too) is cached per model; a
     # network failure for PROPS_FAILURE_TTL seconds, then the next call asks
     # again. A probe cut by this thread's Client.probe_cancel answers
-    # :cancelled, uncached, and the turn's next request ends it.
+    # :cancelled, uncached, and the turn's next request ends it. A completion
+    # or model list this client gets through clears the failures: a server
+    # that just answered is not the down or hung one the window remembered.
     def server_props(model: nil)
       path = @transport.props_path
       return nil unless path
@@ -350,11 +388,12 @@ module Samagotchi
       nil
     end
 
-    # Forget cached /props answers: the server may have restarted with
-    # another -c, or a model switch may have loaded one with a different
-    # window. A recent failure stays until its PROPS_FAILURE_TTL ends: it
-    # holds no stale window, and asking a hung server again at every turn's
-    # start is what it saves.
+    # Forget cached /props answers for this host: the server may have
+    # restarted with another -c, or a model switch may have loaded one with a
+    # different window. The host's entry is shared with every Client of the
+    # same server, so the clear reaches them all. A recent failure stays
+    # until its PROPS_FAILURE_TTL ends: it holds no stale window, and asking
+    # a hung server again at every turn's start is what it saves.
     def invalidate_context_window!
       @props_mutex.synchronize { @props_cache.clear }
     end
@@ -363,6 +402,15 @@ module Samagotchi
 
     def monotonic_now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+    # The host answered a request: whatever a probe failed with (refused,
+    # timed out, 503 while it loaded) is stale, so the next probe asks it
+    # again rather than serving the failure for the rest of its
+    # PROPS_FAILURE_TTL. A cached answer stays: it was read from the same
+    # running server.
+    def clear_props_failures!
+      @props_mutex.synchronize { @props_failures.clear }
+    end
+
     def probe_props(path, model)
       query = model.empty? ? "" : "?#{URI.encode_www_form(model: model)}"
       uri = URI("#{@scheme}://#{@host}:#{@port}#{path}#{query}")

data/lib/samagotchi/commands/registry.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "did_you_mean"
+
 module Samagotchi
   module Commands
     # The slash (and bang) commands a session knows, in lookup order: the
@@ -74,6 +76,32 @@ module Samagotchi
 
       def command?(line) = !lookup(line).nil?
 
+      # A line that is one word: a slash and a name, no spaces, no second
+      # slash. `/modle` is one; `/foo bar` and `/usr/bin/env` are not (they
+      # are prompts).
+      UNKNOWN_COMMAND_WORD = /\A\/[A-Za-z][A-Za-z0-9_-]*\z/
+
+      # Whether +line+ is a command word no command answers: a typo like
+      # `/modle`, which a UI must not send to the model as a prompt.
+      def unknown_command_word?(line)
+        text = line.to_s.strip
+        return false unless UNKNOWN_COMMAND_WORD.match?(text)
+
+        lookup(text).nil? && lookup_local(text).nil?
+      end
+
+      # What a UI shows for an unknown command word, or nil when +line+ is
+      # not one: `Unknown command /modle. Did you mean /model? /help lists
+      # the commands.` The "Did you mean" part needs a close name among the
+      # entries (DidYouMean::SpellChecker).
+      def unknown_command_hint(line)
+        return nil unless unknown_command_word?(line)
+
+        text = line.to_s.strip
+        close = DidYouMean::SpellChecker.new(dictionary: @entries.map(&:name)).correct(text).first
+        "Unknown command #{text}. #{close ? "Did you mean #{close}? " : ""}/help lists the commands."
+      end
+
       # @return [Entry, nil] the first entry the UI runs itself (local) that
       #   matches +line+, whatever its uis (a UI answers the others' too:
       #   the REPL's /detach note)

data/lib/samagotchi/config.rb

@@ -142,6 +142,12 @@ module Samagotchi
       # Asks again in the same turn after an empty answer (EmptyAnswerRetry);
       # 0 = off, capped at 3. No CLI flag: workers get no CLI args.
       Entry.new(key: "retry.empty_answer",       yaml_path: %w[retry empty_answer],       type: :integer, default: 1,               expose: %i[env config]),
+      # A turn's step limit: model ↔ tool rounds before it stops and offers to continue (IterationLimit); integer ≥ 1.
+      # --no-interrupt turns get max(1000, this). No CLI flag: --no-interrupt is the flag.
+      Entry.new(key: "turn.max_iterations",      yaml_path: %w[turn max_iterations],      type: :integer, default: 100,             expose: %i[env config]),
+      # Whether a parent agent (chi answer) may answer Continue to a session's step-limit question; false: Stop only.
+      # config.yml only, like guardrails.parent_approvals: a parent must not decide it from its own environment.
+      Entry.new(key: "turn.parent_continue",     yaml_path: %w[turn parent_continue],     type: :bool,    default: true,            expose: %i[config]),
       # What `chi update` touches; its --no-gem/--no-bundles/--no-desktop turn one off for a run.
       Entry.new(key: "update.gem",               yaml_path: %w[update gem],               type: :bool,    default: true,            expose: %i[env config]),
       Entry.new(key: "update.bundles",           yaml_path: %w[update bundles],           type: :bool,    default: true,            expose: %i[env config]),
@@ -161,7 +167,7 @@ module Samagotchi
       Entry.new(key: "execute.preview_bytes",           yaml_path: %w[execute preview_bytes],           type: :integer, default: 12_288, expose: %i[env config cli]),
       Entry.new(key: "execute.telemetry_threshold_pct", yaml_path: %w[execute telemetry_threshold_pct], type: :integer, default: 80,     expose: %i[env config cli]),
       # Seconds one execute command may run before it is stopped (Tools::Execute::TIMEOUT_SEC).
-      Entry.new(key: "execute.timeout_sec",             yaml_path: %w[execute timeout_sec],             type: :integer, default: 30,     expose: %i[env config cli]),
+      Entry.new(key: "execute.timeout_sec",             yaml_path: %w[execute timeout_sec],             type: :integer, default: 120,    expose: %i[env config cli]),
 
       Entry.new(key: "web.port",                 yaml_path: %w[web port],                 type: :integer, default: 4567,            expose: %i[env config cli]),
       Entry.new(key: "web.host",                 yaml_path: %w[web host],                 type: :string, default: "127.0.0.1",     expose: %i[env config cli]),

data/lib/samagotchi/continue_offer.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Samagotchi
+  # A session worker's continue offer: what it announces when a turn runs out
+  # of iterations, when a prompt or a reminder drops the offer, when a
+  # /continue answers it, and the continue turn a yes runs. TurnFlow keeps
+  # the offer itself (its checkpoint and context); this is the worker's side
+  # of it, which every UI hears about.
+  #
+  # The offer is also a question (kind "continue", the step-limit
+  # question), standing on the Engine's question desk between turns, so
+  # everything built on a pending question sees it: chi send --wait (exit
+  # 3), chi answer, the lists' waiting, the web's badge and bell. Its
+  # answer becomes the matching /continue line on the worker's command
+  # queue, which runs it as a typed one (#run_command's path).
+  class ContinueOffer
+    KIND = "continue"
+    HEADER = "Step limit"
+    CONTINUE = "Continue"
+    STOP = "Stop"
+    PROMPT_PREVIEW = 200
+    # last_turn's outcome after a Stop: no turn ran, but the wait of
+    # whoever answered (chi answer) ends on it.
+    NOT_CONTINUED = "not_continued"
+
+    # @param engine [Engine] announces, records activity, holds the question
+    # @param turn_flow [TurnFlow] owns the offer
+    # @param run_turn [#call] (prompt, **turn_args, &block) the worker's
+    #   run_engine_turn
+    # @param max_iterations [#call] (no_interrupt) → Integer
+    # @param queue_command [#call] (line, client_id:) queues a session
+    #   command as a card's (Bridge#queue_command, card: true)
+    def initialize(engine:, turn_flow:, run_turn:, max_iterations:, queue_command: nil)
+      @engine = engine
+      @turn_flow = turn_flow
+      @run_turn = run_turn
+      @max_iterations = max_iterations
+      @queue_command = queue_command
+      # A question was posted since the last close (it may have been
+      # answered or superseded meanwhile).
+      @asked = false
+    end
+
+    attr_writer :queue_command
+
+    def awaiting? = @turn_flow.awaiting_continue?
+
+    # TurnFlow keeps the checkpoint (a cancelled turn's, for !rollback) and
+    # the continue offer of a turn that ran out of iterations; an offer made
+    # (or kept, after a cancelled continue turn) is announced and asked.
+    def after_turn(result, continue: false, no_interrupt: false)
+      outcome = @turn_flow.after_turn(result, continue: continue, no_interrupt: no_interrupt)
+      return unless outcome == :continue_offered || outcome == :continue_cancelled
+
+      open
+    end
+
+    # A prompt (or a reminder turn) taken while a continue is offered
+    # replaces the answer (D2): the offer goes, the partial turn stays.
+    def drop(origin)
+      return unless awaiting?
+
+      close("dropped")
+      @engine.synchronize_events do
+        @turn_flow.drop_offer!
+        @engine.announce(type: :continue_resolved, decision: "dropped", client_id: origin&.dig(:client_id))
+      end
+      @engine.record_activity
+    end
+
+    # Whether a command's +result+ answered the offer that was pending
+    # (+awaiting+) as it started.
+    def resolved?(awaiting, result)
+      awaiting && result.decision && result.decision != :invalid ? true : false
+    end
+
+    # Called with the event log held, before the command's command_ran. A
+    # Stop runs no turn: last_turn says so (not_continued), so a wait on
+    # it ends (chi answer --option Stop).
+    def announce_resolved(result, command)
+      @engine.announce(type: :continue_resolved, decision: result.decision.to_s, client_id: command[:client_id])
+      return if result.resume
+
+      session = @engine.session
+      session.last_turn = { "outcome" => NOT_CONTINUED, "ended_at" => Time.now.iso8601(3) } if session
+    end
+
+    # After a command's command_ran and save: a /continue that answered the
+    # offer closes its question; a command that dropped the offer
+    # otherwise (!rollback) too.
+    # @param resolved [Boolean] it answered the offer (#resolved?)
+    def after_command(result, resolved:)
+      close(resolved ? "answered" : "dropped") unless awaiting?
+      return unless resolved
+
+      # An offer answered without a turn ("no") is activity: the recap
+      # written at the offer (it says the turn stopped) gets rewritten.
+      @engine.record_activity unless result.resume
+    end
+
+    # The continue offer was answered yes: resume the conversation without a
+    # user message, with the iteration limit the offer's turn had. A failure
+    # keeps the offer, as the REPL does ("continue prompt preserved"), and
+    # asks again.
+    def run_continue_turn(command)
+      offer = @turn_flow.offer
+      close("answered")
+      @turn_flow.before_continue_turn
+      @run_turn.call(nil, continue: true, origin: { client_id: command[:client_id] }.compact,
+                          max_iterations: @max_iterations.call(offer[:no_interrupt])) do |result, error|
+        if error
+          open(offer)
+        else
+          after_turn(result, continue: true, no_interrupt: offer[:no_interrupt])
+        end
+      end
+    end
+
+    # The question goes (the offer went, or was answered).
+    # @param reason [String] dropped, answered
+    def close(reason)
+      return unless @asked
+
+      @asked = false
+      @engine.withdraw_question(reason)
+    end
+
+    private
+
+    def open(offer = @turn_flow.offer)
+      @engine.announce(type: :continue_offered, context: offer[:context], no_interrupt: offer[:no_interrupt])
+      ask
+    end
+
+    # Post the step-limit question while the offer stands (again, after a
+    # question that superseded it closed).
+    def ask
+      return unless awaiting?
+
+      @asked = true
+      @engine.post_question(question_fields(@turn_flow.offer), on_answer: method(:answered),
+                                                               on_superseded_close: method(:ask))
+    end
+
+    def question_fields(offer)
+      limit = limit_of_last_turn
+      context = offer[:context] || {}
+      text = "The turn ran out of iterations#{" (#{limit} steps)" if limit} before it answered. Continue it?"
+      prompt = context[:original_prompt].to_s.strip
+      unless prompt.empty?
+        prompt = "#{prompt[0, PROMPT_PREVIEW].rstrip}..." if prompt.length > PROMPT_PREVIEW
+        text += "\nPrompt: #{prompt}"
+      end
+      { kind: KIND, header: HEADER, question: text, options: [CONTINUE, STOP], multi_select: false,
+        allow_freeform: true, limit: limit, context: context }.compact
+    end
+
+    # The limit the offer's turn ran out at (Engine's last_turn marker).
+    def limit_of_last_turn
+      last = @engine.session&.last_turn
+      last.is_a?(Hash) && last["exhausted"] ? last["limit"] : nil
+    end
+
+    # The question's answer as the /continue line a typed answer would be:
+    # Continue → yes; Stop → no; a text (with Stop, or alone) → no, <text>.
+    def answered(answer, client_id:)
+      text = answer[:freeform].to_s.gsub(/\s+/, " ").strip
+      line = if Array(answer[:selected]).include?(CONTINUE) then "/continue yes"
+             elsif text.empty? then "/continue no"
+             else "/continue no, #{text}"
+             end
+      @queue_command&.call(line, client_id: client_id)
+    end
+  end
+end

data/lib/samagotchi/engine.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "time"
 require "yaml"
 
+require_relative "iteration_limit"
 require_relative "config"
 require_relative "context_note"
 require_relative "context_status"
@@ -27,6 +28,7 @@ require_relative "llm/backend"
 require_relative "llm/openai_chat"
 require_relative "llm/turn_settings"
 require_relative "session"
+require_relative "answer_tail"
 require_relative "archive_store"
 require_relative "session_observer"
 require_relative "tool_declarations"
@@ -83,7 +85,7 @@ module Samagotchi
     # @param profile            [ModelProfile, Symbol, String, nil]
     # @param session_id         [String, nil] resume an existing session
     # @param no_interrupt       [Boolean] --no-interrupt: every turn runs with
-    #   NO_INTERRUPT_MAX_ITERATIONS, whichever loop runs it
+    #   IterationLimit.for(no_interrupt: true), whichever loop runs it
     # @param model_name         [String, nil] defaults from SAMAGOTCHI_DEFAULT_MODEL
     # @param model_typed        [String, nil] the name the model was given as (a session's
     #   model_typed: an alias), for the models: lookup; model_name by default
@@ -92,10 +94,6 @@ module Samagotchi
     #   prompt's index, dropped from the preloads, refused by memory_read); a mute wins over a preload
     # What memory_write answers in a scratch session.
     SCRATCH_MEMORY_WRITE = "Error: scratch session: nothing is saved"
-    # A turn's iteration limit with no_interrupt (the worker's own
-    # --no-interrupt turns pass the same).
-    NO_INTERRUPT_MAX_ITERATIONS = 1000
-
     # @param plugins            [Boolean] false: load no bundle plugins (a throwaway Engine for a prompt)
     # @param scratch            [Boolean] a `chi scratch` session: memory writes are refused, and there is no
     #   delegate (a child would outlive it) nor plugin fork
@@ -144,7 +142,8 @@ module Samagotchi
         model_key: -> { @model_key },
         model_name: -> { guardrail_model_name },
         cancelled: -> { !!active_cancel_controller&.cancelled? },
-        ask: ->(fields) { open_question(fields) }
+        ask: ->(fields) { open_question(fields) },
+        notify: ->(message) { guardrail_notify(message) }
       )
       @guardrail_failures = @guardrail_wiring.failures
       # Plugins that failed to load: announced apart, as plugins (not
@@ -1081,7 +1080,10 @@ module Samagotchi
 
     # How the turn ended, on the session (Session#last_turn): the caller's
     # save puts it in the file the session hub watches.
-    def record_last_turn(session, outcome, seconds, origin)
+    # @param limit [Integer, nil] the turn ran out of iterations at this
+    #   limit: "exhausted" => true, "limit" => N, so a wait with nobody to
+    #   answer the continue offer says so (ReplyWait, ParentReport "limit")
+    def record_last_turn(session, outcome, seconds, origin, limit: nil)
       client_id = origin.is_a?(Hash) ? origin[:client_id].to_s : ""
       source = if client_id.start_with?("#{Tools::Delegate::CLIENT_PREFIX}:") then "delegate"
                elsif client_id == SessionManager::REMINDER_CLIENT_ID then "reminder"
@@ -1089,6 +1091,7 @@ module Samagotchi
                end
       session.last_turn = { "outcome" => outcome, "ended_at" => Time.now.iso8601(3),
                             "seconds" => seconds.round(1), "origin" => source }
+      session.last_turn.merge!("exhausted" => true, "limit" => limit) if limit
     end
     private :record_last_turn
 
@@ -1101,14 +1104,15 @@ module Samagotchi
     # returns [the messages to keep (nil: leave the session's), the end
     # event]. +save:+ also saves the session (a failed turn: a worker exits
     # after it). The disk writes come after the step: every emitter waits
-    # for the event lock.
-    def end_turn(turn, outcome, save: false)
+    # for the event lock. +exhausted:+ the turn ran out of iterations
+    # (its limit goes in last_turn).
+    def end_turn(turn, outcome, save: false, exhausted: false)
       seconds = turn.elapsed
       synchronize_events do
         kept, event = yield(seconds)
         replace_session_messages(turn.session, kept) if kept
         turn.session.status = Session::STATUS_IDLE
-        record_last_turn(turn.session, outcome, seconds, turn.origin)
+        record_last_turn(turn.session, outcome, seconds, turn.origin, limit: exhausted ? turn.limit : nil)
         emit_event(turn.on_event, turn.tag(event))
       end
       turn.ended = true
@@ -1191,6 +1195,16 @@ module Samagotchi
     end
     private :hook_notify
 
+    # A guardrails line to the user after load (:guardrail_warning, as the
+    # load failures show): a running turn's event, else announced.
+    def guardrail_notify(message)
+      event = { type: :guardrail_warning, message: message.to_s }
+      in_turn, sink = @turn_state.in_turn_sink
+      in_turn ? emit_event(sink, event) : announce_or_hold(event)
+      nil
+    end
+    private :guardrail_notify
+
     # A question through the question flow (REPL sync handler, attached TUI,
     # web), single-select, kind "hook". A --non-interactive run has no one
     # to ask: nil at once. Anything but an answer (a sync handler's text, no
@@ -1254,6 +1268,19 @@ module Samagotchi
       @question_desk.open_question({ **fields.to_h, **more }, watch: watch)
     end
 
+    # Publish a standing question that blocks nobody (QuestionDesk#post: a
+    # worker's step-limit question).
+    # @return [Hash, nil] the pending question, nil while another is open
+    def post_question(fields, on_answer:, on_superseded_close: nil)
+      @question_desk.post(fields, on_answer: on_answer, on_superseded_close: on_superseded_close)
+    end
+
+    # Withdraw the standing question (QuestionDesk#withdraw).
+    # @return [Boolean]
+    def withdraw_question(reason, id: nil)
+      @question_desk.withdraw(reason, id: id)
+    end
+
     # Answer the pending question (called from UI thread; QuestionDesk#answer).
     # @return [Hash] normalized answer
     def answer_question(id:, selected:, freeform: nil, client_id: nil, parent_agent: nil)
@@ -1274,6 +1301,7 @@ module Samagotchi
 
     # Cancel the pending question (QuestionDesk#cancel).
     # @return [Boolean] whether it was cancelled
+    # @raise [QuestionDesk::NotDismissable] +id+ names a standing question
     def cancel_question(reason = "user", id: nil)
       @question_desk.cancel(reason, id: id)
     end
@@ -1414,8 +1442,9 @@ module Samagotchi
     # set on the kernel in #generate.
     # +id+: names the turn on :turn_started (its metrics record's id) and on
     # its saved prompt, so a UI pairs the two whatever left the conversation.
+    # +limit+: the iteration limit #generate ran it with.
     Turn = Struct.new(:session, :prompt, :continue, :on_event, :controller, :origin, :started_at, :messages, :ended,
-                      :settings, :id) do
+                      :settings, :id, :limit) do
       # The turn's boundary events carry the origin only when there is one,
       # so payloads stay unchanged for callers that don't pass it.
       def tag(event) = origin ? event.merge(origin: origin) : event
@@ -1433,7 +1462,7 @@ module Samagotchi
     # @param session  [Session] the session to operate on
     # @param prompt   [String] user input
     # @param on_event [Proc, nil] receives event hashes
-    # @param max_iterations [Integer] max kernel iterations
+    # @param max_iterations [Integer, nil] max kernel iterations (nil: IterationLimit.for)
     # @param cancel_controller [CancellationController, nil]
     # @param max_tool_output_chars [Integer, nil] per-output char cap for the
     #   :tool_call_completed event's `output:` (nil → max_tool_output_chars)
@@ -1462,7 +1491,7 @@ module Samagotchi
     # other error (e.g. an LLM::ProviderError) emits :turn_failed and
     # re-raises; a provider error adds error_kind:, retryable:, host: and a
     # one-line summary:.
-    def run_turn(session, prompt, on_event: nil, max_iterations: 100, cancel_controller: nil, max_tool_output_chars: nil, pending_input: nil, continue: false, origin: nil,
+    def run_turn(session, prompt, on_event: nil, max_iterations: nil, cancel_controller: nil, max_tool_output_chars: nil, pending_input: nil, continue: false, origin: nil,
                  images: [])
       turn = begin_turn(session, prompt, on_event: on_event, cancel_controller: cancel_controller, origin: origin,
                                          continue: continue)
@@ -1551,13 +1580,13 @@ module Samagotchi
       emit_event(turn.on_event, turn.tag(turn_started))
       raise image_error if image_error
 
-      # Ask the server for its window again each turn (one short /props GET,
-      # cached across the turn's generations): a restart with another -c
-      # between turns raises no error that would drop the cache. The
-      # profile may probe too (a first turn, a retry). Both run after
-      # run_turn's probe-cancel swap, so a Stop cuts them, and a failure
-      # ends the turn as turn_failed.
-      @client.invalidate_context_window!
+      # The window and the profile probes run after run_turn's probe-cancel
+      # swap, so a Stop cuts them; a failure ends the turn as turn_failed.
+      # The cache itself was dropped at the previous turn's end, so this
+      # turn's first probe asks the server (a restart with another -c
+      # between turns is noticed), and the answer the session's prompt build
+      # read for its profile (a first turn) is what this turn starts from:
+      # one GET /props per turn, not two.
       refresh_profile!
 
       # Before anything of the turn is kept or a reminder is used up.
@@ -1666,9 +1695,10 @@ module Samagotchi
       # turn's model, not the last native one.
       @kernel.turn_settings = turn.settings.with(model_name: bare_for_backend, window_setting: turn_window_setting)
 
+      turn.limit = @no_interrupt ? IterationLimit.for(no_interrupt: true) : max_iterations || IterationLimit.for
       backend.complete(
         messages: turn.messages,
-        max_iterations: @no_interrupt ? NO_INTERRUPT_MAX_ITERATIONS : max_iterations,
+        max_iterations: turn.limit,
         on_stream_event: build_stream_event_handler(turn.on_event, cancel_controller: turn.controller),
         cancel_controller: turn.controller,
         model_name: bare_for_backend,
@@ -1705,7 +1735,7 @@ module Samagotchi
       # after_turn hooks run below and may present the answer (the web
       # holds its pop until it knows).
       display_pending = !canceled && @hooks.any?(:after_turn)
-      end_turn(turn, canceled ? "canceled" : "completed") do |seconds|
+      end_turn(turn, canceled ? "canceled" : "completed", exhausted: !canceled && result.exhausted?) do |seconds|
         kept = kept_messages(turn, result, seconds)
         if canceled
           [kept, { type: :turn_canceled, cancellation_reason: result.cancellation_reason,
@@ -1809,6 +1839,13 @@ module Samagotchi
       # treats the just-finished turn as activity and re-arms its window.
       left = @turn_state.finish!
       Client.swap_probe_cancel(probe_cancel_before)
+      # The next turn's window and served model are asked again: the cache
+      # (this host's, process-wide) is dropped here, at the turn's end,
+      # rather than at its start, so what this turn read (the profile's own
+      # probe included) is not asked for a second time within the turn. A
+      # restart with another -c between turns is still noticed: the next
+      # turn's first probe goes to the server.
+      @client.invalidate_context_window!
       log_dropped_steers(left, "turn_ended")
       record_activity
       # Clear hooks so they remain turn-scoped and never leak into the next turn.
@@ -1968,6 +2005,15 @@ module Samagotchi
     # rollback after Ctrl-C). Each replaces the array rather than mutating it,
     # so the recap's lock-free snapshot never sees a half-applied edit.
 
+    # The answer a UI shows last (AnswerTail), a copy of that one message
+    # only: walked back from the end, never a #messages_checkpoint of the
+    # whole conversation (the Bridge's GET tail). +turn_id+: that turn's
+    # answer (AnswerTail.find); unknown or nil: the newest.
+    # @return [Hash, nil]
+    def last_answer_message(turn_id: nil)
+      AnswerTail.find(@session&.messages, turn_id: turn_id)&.dup
+    end
+
     # @return [Array<Hash>] a copy of the current session's messages to hand
     #   back to #rollback_to later
     def messages_checkpoint