samagotchi 0.23.0 → 0.25.0

data/lib/samagotchi/bridge.rb

@@ -20,6 +20,7 @@ require_relative "session"
 require_relative "engine"
 require_relative "guardrails/parent_approvals"
 require_relative "session_commands"
+require_relative "steer"
 require_relative "image_store"
 require_relative "log"
 require_relative "version"
@@ -780,6 +781,8 @@ module Samagotchi
       end
 
       enqueued_id = SecureRandom.uuid
+      # Before it is queued: a drain after this may have taken it (#cut_for_steer).
+      epoch = @engine.input_epoch
       # Write and announce with the event log held: the worker can't emit
       # this turn's :turn_started (or merge it mid-turn) before
       # :turn_enqueued, and a failed write announces nothing.
@@ -799,6 +802,10 @@ module Samagotchi
       return deadline_passed("turn") if enqueued == :expired
       return [{}, 500, { error: "enqueue_failed", detail: "could not write turn input" }] unless enqueued
 
+      # Queued (outside the event lock): a running generation that has only
+      # been thinking for long is cut for it, unless a plugin sent it. An
+      # image input never merges mid-turn, so it never cuts.
+      @engine.cut_for_steer(Steer.source_for_client(client_id), epoch: epoch) if images.empty?
       [{}, 202, { status: "accepted", enqueued_id: enqueued_id, session_id: @session_id }]
     end
 

data/lib/samagotchi/bundles/check-in/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: check-in
-version: 0.2.2
+version: 0.2.3
 scope: system
 description: "Checks on a long turn: after N tool calls with no answer, a card asks the user (Nudge / Keep going / Stop), or the model is nudged to say what it has found"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:52fcb0a3beccfee1e70e7d73162eace603da11bee43e535b1bc17d55eae98334
+  sha256: sha256:821aea2821df12f278db9a94f8150244e67bf9453735d19a5abe9d94253eefa6
 requires_chi: ">= 0.3.0"

data/lib/samagotchi/bundles/check-in/plugin.rb

@@ -147,7 +147,8 @@ class Plugin
       role = (message[:role] || message["role"]).to_s
       kind = (message[:kind] || message["kind"]).to_s
       return true if kind == "steer" && (message[:content] || message["content"]).to_s.strip == text.strip
-      return false if role == "user" && kind != "steer"
+      # A user line merged into the turn (kind input) is part of it: look past it.
+      return false if role == "user" && !%w[steer input].include?(kind)
     end
     false
   end

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

@@ -1,10 +1,10 @@
 ---
 name: loop-guard
-version: 0.3.2
+version: 0.3.3
 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:27b135c462d8462313edaa1faa90f3104a1bff3c421d6965e9e71955f347d55b
+  sha256: sha256:8cf255cd1cc0846a759fcf70144af53bfc634c9d5c766981ce0ef5e476749e0a
 requires_chi: ">= 0.6.0"

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

@@ -56,12 +56,20 @@ require "digest"
 #   too ("Hmm.", "Fine."), but spread out, or in runs of different ones
 #   (code lines); a sentence of min_words or more ends the run, one with no
 #   letters or digits neither counts nor ends it. Lines inside a ``` code
-#   block are not short sentences.
+#   block are not short sentences;
+# - a low-diversity window: among the last window_sentences sentences of any
+#   length, at most window_distinct different ones (exact, normalized). It
+#   sees a cycle too long for the short run (7-8 short sentences), or one
+#   where a longer sentence keeps ending the run ("Go. OK. I'll write the
+#   spec file now. Go."). Real thinking holds 40+ different sentences in
+#   any 48 (the lowest seen: 42); a loop holds under 10. Lines inside a ```
+#   code block don't count.
 # Nothing triggers before min_chars of thinking. O(new chars) per feed.
 class ThinkingWatch
   DEFAULTS = { "watch" => true, "action" => "retry", "min_chars" => 2000, "repeats" => 3, "max_period" => 6,
                "similarity" => 0.5, "min_span_sentences" => 6, "min_span_chars" => 600, "max_same" => 8,
-               "min_words" => 5, "short_run" => 24, "short_distinct" => 6, "forget_after" => 10 }.freeze
+               "min_words" => 5, "short_run" => 24, "short_distinct" => 6, "window_sentences" => 48,
+               "window_distinct" => 12, "forget_after" => 10 }.freeze
   ACTIONS = %w[retry stop notify].freeze
   MAX_CARRY = 400
   # One sentence again and again needs this much more alike than a cycle.
@@ -81,7 +89,7 @@ class ThinkingWatch
     out["watch"] = !%w[false no off 0].include?(raw["watch"].to_s.downcase) if raw.key?("watch")
     out["action"] = raw["action"].to_s if ACTIONS.include?(raw["action"].to_s)
     %w[min_chars repeats max_period min_span_sentences min_span_chars max_same min_words short_run
-       short_distinct].each do |key|
+       short_distinct window_sentences window_distinct].each do |key|
       number = Integer(raw[key].to_s, exception: false)
       out[key] = number if number&.positive?
     end
@@ -104,6 +112,8 @@ class ThinkingWatch
     @min_words = settings["min_words"]
     @short_run = settings["short_run"]
     @short_distinct = settings["short_distinct"]
+    @window_sentences = settings["window_sentences"]
+    @window_distinct = settings["window_distinct"]
     @same_similarity = [@similarity + SAME_MARGIN, 0.95].min
     @carry = +""
     @window = [] # the last max_period + 1 sentences
@@ -112,6 +122,8 @@ class ThinkingWatch
     @counts = Hash.new(0)
     @short_count = 0  # short sentences in a row
     @short_window = [] # the last short_run of them, [key, text]
+    @recent = [] # the last window_sentences sentences, [key, text]
+    @recent_counts = Hash.new(0) # key => times in @recent
     @in_code = false
     @thinking_chars = 0
   end
@@ -153,7 +165,8 @@ class ThinkingWatch
     end
     words = text.downcase.gsub(/[^[:alnum:]]+/, " ").split
     short = short_loop(text.strip, words) unless @in_code
-    return (short if @thinking_chars >= @min_chars) if words.length < @min_words
+    window = window_loop(text.strip, words) unless @in_code
+    return (@thinking_chars >= @min_chars ? short || window : nil) if words.length < @min_words
 
     key = words.join(" ")
     sentence = Sentence.new(text: text.strip, words: words.map(&:hash).uniq,
@@ -164,7 +177,27 @@ class ThinkingWatch
     @window.shift if @window.length > @max_period + 1
     return nil if @thinking_chars < @min_chars
 
-    cycle || (same >= @max_same ? Loop.new(period: 1, times: same, sentences: [sentence.text], chars: nil) : nil)
+    cycle || (same >= @max_same ? Loop.new(period: 1, times: same, sentences: [sentence.text], chars: nil) : nil) || window
+  end
+
+  # The last window_sentences sentences (any length) hold at most
+  # window_distinct different ones: a loop. Its sentences are the most
+  # frequent first.
+  def window_loop(text, words)
+    return nil if words.empty?
+
+    key = words.join(" ")
+    @recent << [key, text]
+    @recent_counts[key] += 1
+    if @recent.length > @window_sentences
+      old, = @recent.shift
+      @recent_counts.delete(old) if (@recent_counts[old] -= 1).zero?
+    end
+    return nil if @recent.length < @window_sentences || @recent_counts.size > @window_distinct
+
+    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)
   end
 
   def short_loop(text, words)
@@ -276,14 +309,17 @@ class Plugin
     @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"
+    # 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}"
     case @thinking["action"]
     when "notify"
-      ctx.notify("thinking repeats itself (#{what})", level: :warn)
+      ctx.notify("thinking repeats itself (#{quoted})", level: :warn)
     when "retry"
       @thinking_loops += 1
       return stop_thinking(ctx, found, what) if @thinking_loops > 1
 
-      ctx.notify("thinking repeats itself (#{what}): cut", level: :warn) if ctx.stop_generation("its thinking kept repeating itself")
+      ctx.notify("thinking repeats itself (#{quoted}): cut", level: :warn) if ctx.stop_generation("its thinking kept repeating itself")
     else
       stop_thinking(ctx, found, what)
     end

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

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

data/lib/samagotchi/command_steps.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require_relative "guardrails/shell_lex"
+
+module Samagotchi
+  # An execute command as the steps a person reads, for the web's tool row
+  # (display only: the guardrails read the command themselves). Built from
+  # ShellLex's tokens and their spans, so each step's text is a slice of the
+  # command as the model wrote it. Rules, in order:
+  #
+  # - a heredoc's body leaves its step's text and becomes its +heredoc+
+  #   ({tag:, lines:}), also one inside a "$(cat <<'EOF' … EOF)" argument;
+  # - steps are split at && || ; | |& & and newlines; a ( … ) subshell stays
+  #   one step; +op+ is the operator before a step (nil for the first);
+  # - a leading "cd X &&" / "cd X;" becomes +cd+ (only the first);
+  # - a pipeline's last "| head …" / "| tail …" becomes the +limit+ of the
+  #   step before it ("head 20", "tail", "head -c 60");
+  # - a lone echo of a marker-wrapped string ("=== x ===", "--- x ---",
+  #   "## x") becomes the +label+ of the next step; a bare marker echo
+  #   ("---", "====", "") only spaces the output and goes;
+  # - anything the parser isn't sure of (a quote or heredoc left open,
+  #   for/while/until/if/case/function bodies, { … } groups, unbalanced
+  #   parentheses) gives nil: the UI then shows the title and the raw
+  #   command.
+  module CommandSteps
+    Step = Data.define(:text, :op, :label, :limit, :heredoc) do
+      def initialize(text:, op: nil, label: nil, limit: nil, heredoc: nil) = super
+
+      def to_h = super.compact
+    end
+
+    Parsed = Data.define(:cd, :steps) do
+      def to_h = { cd: cd, steps: steps.map(&:to_h) }.compact
+    end
+
+    Lex = Guardrails::ShellLex
+
+    SPLIT = ["&&", "||", ";", "|", "|&", "&", "\n"].freeze
+    KEYWORDS = %w[for while until if then elif else fi case esac select do done function { }].freeze
+    LIMITERS = %w[head tail].freeze
+    MARKER = /\A\s*(?:={2,}|-{2,}|#+)\s*(.*?)\s*(?:={2,}|-{2,})?\s*\z/m
+    ECHO_FLAGS = %w[-e -n -en -ne].freeze
+
+    module_function
+
+    # @return [Parsed, nil] nil when the command isn't plain enough to show
+    #   as steps
+    def parse(command)
+      text = command.to_s
+      lexer = Lex::Lexer.new(text)
+      tokens = lexer.tokens.zip(lexer.spans).map { |token, span| [*token, span] }
+      return nil if lexer.unterminated? || tokens.empty?
+
+      bodies = lexer.heredoc_spans.to_h { |doc| [doc[:span], doc[:tag]] }
+      raw = split(tokens)
+      return nil if raw.nil? || raw.empty?
+
+      steps = raw.map { |op, words| step(text, op, words, bodies) }
+      return nil if steps.any?(&:nil?)
+
+      cd, steps = leading_cd(steps, raw)
+      steps = labels(limits(steps))
+      steps.empty? ? nil : Parsed.new(cd: cd, steps: steps)
+    end
+
+    # [[op, word tokens]] split at SPLIT outside parentheses; nil for a
+    # control keyword at a command's start, ;; or unbalanced parentheses.
+    def split(tokens)
+      steps = []
+      op = nil
+      words = []
+      depth = 0
+      tokens.each do |token|
+        kind, value = token
+        if kind == :op && value == "("
+          depth += 1
+          words << token
+        elsif kind == :op && value == ")"
+          depth -= 1
+          return nil if depth.negative?
+
+          words << token
+        elsif kind == :op && depth.zero?
+          return nil unless SPLIT.include?(value)
+
+          if words.empty?
+            op = value unless value == "\n" # "a;\nb" keeps the ;
+          else
+            steps << [steps.empty? ? nil : op, words]
+            op = value
+          end
+          words = []
+        else
+          return nil if keyword?(words, token)
+
+          words << token
+        end
+      end
+      return nil unless depth.zero?
+
+      steps << [steps.empty? ? nil : op, words] unless words.empty?
+      steps
+    end
+
+    # Whether +token+ is a control keyword where a command starts (the
+    # step's first word, or the first after a "(" inside it).
+    def keyword?(words, token)
+      return false unless token[0] == :word
+
+      at_start = words.empty? || words.last[0] == :op
+      at_start && KEYWORDS.include?(token[1])
+    end
+
+    # A Step from its tokens: the text from the first to the last token,
+    # heredoc bodies cut out.
+    def step(text, op, tokens, bodies)
+      body = tokens.find { |t| bodies.key?(t.last) }
+      shown = tokens.reject { |t| bodies.key?(t.last) }
+      from = shown.map { |t| t.last.begin }.min
+      to = shown.map { |t| t.last.end }.max
+      return nil unless from
+
+      slice = text[from...to]
+      heredoc = body && { tag: bodies[body.last], lines: body_lines(text[body.last]) }
+      slice, heredoc = inner_heredoc(slice) unless heredoc
+      Step.new(text: slice.strip, op: op, heredoc: heredoc)
+    end
+
+    # A heredoc inside a $(…) in +slice+ (git commit -m "$(cat <<'EOF' …)"):
+    # the slice with the body cut out, and the heredoc; or the slice as is.
+    def inner_heredoc(slice)
+      return [slice, nil] unless slice.include?("<<")
+
+      at = 0
+      while (open = slice.index("$(", at))
+        lexer = Lex::Lexer.new(slice[(open + 2)..])
+        lexer.tokens
+        doc = lexer.heredoc_spans.first
+        if doc
+          from = open + 2 + doc[:span].begin - 1 # the newline before the body
+          to = open + 2 + doc[:span].end
+          to += 1 if slice[to] == "\n"
+          return [slice[0...from] + slice[to..], { tag: doc[:tag], lines: body_lines(slice[(from + 1)...to]) }]
+        end
+        at = open + 2
+      end
+      [slice, nil]
+    end
+
+    # The body's line count, its terminator line not counted.
+    def body_lines(body_and_tag) = [body_and_tag.to_s.chomp.lines.size - 1, 0].max
+
+    # A first "cd X" step followed by && or ; becomes the cd.
+    def leading_cd(steps, raw)
+      words = raw.first[1]
+      next_op = steps[1]&.op
+      plain = words.size == 2 && words.all? { |t| t[0] == :word } && !words[1][1].include?(Lex::SUBST)
+      return [nil, steps] unless plain && words[0][1] == "cd" && ["&&", ";"].include?(next_op)
+
+      [words[1][1], [steps[1].with(op: nil), *steps.drop(2)]]
+    end
+
+    # A pipeline's last head/tail becomes the limit of the step before it.
+    def limits(steps)
+      steps.each_with_index.with_object([]) do |(step, i), out|
+        limit = step.op == "|" && !out.empty? && out.last.limit.nil? && limit_of(step.text)
+        if limit && !["|", "|&"].include?(steps[i + 1]&.op)
+          out[-1] = out.last.with(limit: limit)
+        else
+          out << step
+        end
+      end
+    end
+
+    # "head 20" for "head -n 20" / "head -20" / "head -n20"; "head -c 60";
+    # "tail +5"; "head" alone. nil for anything else (tail -f, a file).
+    def limit_of(text)
+      words = Lex.lex(text)
+      return nil unless words.all? { |t| t[0] == :word }
+
+      name, *args = words.map { |t| t[1] }
+      return nil unless LIMITERS.include?(name)
+
+      count = case args
+              in [] then nil
+              in [/\A-\d+\z/ => arg] then arg[1..]
+              in [/\A-n\+?\d+\z/ => arg] then arg[2..]
+              in ["-n", /\A\+?\d+\z/ => arg] then arg
+              in ["-c", /\A\d+\z/ => arg] then "-c #{arg}"
+              else return nil
+              end
+      [name, count].compact.join(" ")
+    end
+
+    # A marker echo labels the next step; a bare one goes.
+    # A dropped echo's op goes to the step after it (the link from the
+    # step before).
+    def labels(steps)
+      out = []
+      label = nil
+      op = nil
+      steps.each_with_index do |step, i|
+        marker = marker_label(step.text)
+        if marker.nil? || (!marker.empty? && i == steps.size - 1)
+          step = step.with(label: label, op: op || step.op) if op
+          out << (out.empty? ? step.with(op: nil) : step)
+          label = op = nil
+        else
+          label = marker unless marker.empty?
+          op ||= step.op || "\n"
+        end
+      end
+      out
+    end
+
+    # The label of a lone marker echo ("" for a bare marker or an empty
+    # echo), nil for any other step.
+    def marker_label(text)
+      words = Lex.lex(text)
+      return nil unless words.all? { |t| t[0] == :word && !t[1].include?(Lex::SUBST) }
+
+      name, *args = words.map { |t| t[1] }
+      args.shift while ECHO_FLAGS.include?(args.first)
+      return nil unless name == "echo" && args.size <= 1
+      return "" if args.empty? || args[0].strip.empty?
+
+      match = MARKER.match(args[0])
+      return nil unless match && args[0].strip.match?(/\A(?:={2,}|-{2,}|#)/)
+
+      match[1].strip
+    end
+  end
+end

data/lib/samagotchi/config.rb

@@ -144,6 +144,10 @@ 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]),
+      # Seconds a generation must have streamed only thinking before a message
+      # for the running turn (the user's, chi send's, a parent agent's) cuts
+      # it (Engine#cut_for_steer); 0 = never. No CLI flag: workers get no CLI args.
+      Entry.new(key: "steer.cut_after",          yaml_path: %w[steer cut_after],          type: :integer, default: 20,              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]),
@@ -170,6 +174,8 @@ module Samagotchi
       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: 120,    expose: %i[env config cli]),
+      # Whether execute declares its optional description parameter (a few model-written words, a tool row's title).
+      Entry.new(key: "execute.description",             yaml_path: %w[execute description],             type: :bool,    default: true,   expose: %i[env config]),
 
       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]),
@@ -662,8 +668,9 @@ module Samagotchi
     # A `sampling:` setting (hosts entry or models: entry): request parameters
     # passed through to the provider as written (keys symbolized, nested maps
     # too, so e.g. chat_template_kwargs works). A null value means "don't
-    # send it" (drops chi's own temperature default). Not a map: warns once,
-    # nil. Reserved keys warn once and are dropped. nil when nothing is left.
+    # send it" (a null temperature also keeps the empty-answer retry from
+    # setting one). Not a map: warns once, nil. Reserved keys warn once and
+    # are dropped. nil when nothing is left.
     def sampling_map(value, where)
       return nil if value.nil?
 

data/lib/samagotchi/empty_answer_retry.rb

@@ -13,8 +13,8 @@ module Samagotchi
   # when the retries run out.
   class EmptyAnswerRetry
     MAX = 3
-    # Greedy decoding on a near-identical prompt would likely loop again:
-    # the retry runs at this temperature unless one is configured.
+    # The same (or greedy) decoding on a near-identical prompt would likely
+    # loop again: the retry runs at this temperature unless one is configured.
     TEMPERATURE = 0.6
     # A generation cut at the provider's output cap (finish_reason length)
     # is retried unless the context is this full.

data/lib/samagotchi/engine.rb

@@ -22,6 +22,7 @@ require_relative "session_commands"
 require_relative "plugin/loader"
 require_relative "log"
 require_relative "log_subscriber"
+require_relative "thinking_tails"
 require_relative "client"
 require_relative "host_registry"
 require_relative "llm/backend"
@@ -47,6 +48,8 @@ require_relative "tools/memory"
 require_relative "muted_memories"
 require_relative "used_memories"
 require_relative "turn_state"
+require_relative "generation_phase"
+require_relative "waiting_steer"
 require_relative "bundle_needs"
 require_relative "model_overlay"
 require_relative "served_model"
@@ -103,6 +106,10 @@ module Samagotchi
       # steers) and the idle layer's activity clock. Built first: a plugin
       # may steer or ask whether a turn runs while it loads.
       @turn_state = TurnState.new(clock: -> { monotonic_now })
+      # What the running generation streams: whether a steer may cut it.
+      @generation_phase = GenerationPhase.new(clock: -> { monotonic_now })
+      # A message that may cut it but came too early: it cuts later.
+      @waiting_steer = WaitingSteer.new
       @scratch = scratch
       @no_interrupt = no_interrupt
       @chat_backend = nil
@@ -166,8 +173,9 @@ module Samagotchi
       @hooks = load_hooks_from_config
       load_hooks_from_bundles
       # The tools this session offers (the prompts' declarations and the
-      # kernel's dispatch): the built-ins, per Engine.
-      @tools = Tools::Builtins.registry
+      # kernel's dispatch): the built-ins, per Engine. execute.description
+      # off: execute offers no description parameter.
+      @tools = Tools::Builtins.registry(command_description: Config.get("execute.description") != false)
       if @scratch
         # A scratch session's children would outlive it, and so would a
         # note it left in a peer; its memories would too (write and edit
@@ -276,6 +284,10 @@ module Samagotchi
       @session_observer.subscribe(observer: @metrics)
       # And the event trail in the debug log (`turn` records).
       @session_observer.subscribe(observer: LogSubscriber.new(session_id: -> { @session&.id }))
+      # The thinking of cut and capped generations, kept in the session dir.
+      @session_observer.subscribe(observer: ThinkingTails.new(session_dir: lambda {
+        @session&.id && Session.session_dir(@session.id, state_dir: session_state_dir)
+      }))
     end
 
     # A monotonically-increasing clock (wall clock can jump backwards; the idle
@@ -325,6 +337,69 @@ module Samagotchi
       @turn_state.steer(text, source: source)
     end
 
+    # A message for the running turn from +source+ (Steer.source_for_client:
+    # nil for the user, "chi_send", "parent_agent") cuts the streaming
+    # generation when it has streamed only thinking for steer.cut_after
+    # seconds (GenerationPhase): the loops' cut path then starts the step
+    # again with the message, no nudge, no retry spent. Too early, the
+    # message waits (WaitingSteer) and cuts once the thinking passes it
+    # (#recheck_waiting_steer, on each thinking chunk), unless a boundary
+    # hands it to the model first. A plugin's message never cuts.
+    # Call it after the message is queued, with the #input_epoch read
+    # before queueing it. Outside any lock; a cut that lands just after the
+    # generation ended is harmless (the loop re-asks).
+    # @return [Boolean] whether a generation was cut now
+    def cut_for_steer(source, epoch: nil)
+      return false unless Steer.cuts?(source)
+
+      after = Config.get("steer.cut_after").to_i
+      return false unless after.positive?
+
+      ctrl = active_cancel_controller
+      return false unless ctrl
+      return steer_cut!(ctrl, source.to_s) if @generation_phase.cuttable?(after)
+
+      Log.info(:turn, "steer_cut_waits", source: source.to_s) if @waiting_steer.wait!(source, epoch: epoch)
+      false
+    rescue StandardError
+      false
+    end
+
+    # The drains that took input so far (WaitingSteer#epoch): read it before
+    # queueing a message for #cut_for_steer.
+    def input_epoch
+      @waiting_steer.epoch
+    end
+
+    # A thinking chunk streamed: a waiting message cuts once the thinking
+    # passes steer.cut_after.
+    def recheck_waiting_steer
+      return unless @waiting_steer.waiting?
+
+      after = Config.get("steer.cut_after").to_i
+      return unless after.positive? && @generation_phase.cuttable?(after)
+
+      source = @waiting_steer.take
+      ctrl = active_cancel_controller
+      steer_cut!(ctrl, source, waited: true) if source && ctrl
+    rescue StandardError
+      nil
+    end
+    private :recheck_waiting_steer
+
+    def steer_cut!(ctrl, source, waited: false)
+      age = @generation_phase.age
+      cut = ctrl.cancel_generation!(:steer, { by: "steer", steer: true, source: source, reason: "a new message" })
+      if cut
+        @waiting_steer.clear!
+        fields = { source: source, age: age&.round(1) }
+        fields[:waited] = true if waited
+        Log.info(:turn, "steer_cut", **fields)
+      end
+      cut
+    end
+    private :steer_cut!
+
     # Like #steer, for the turn that begins next (a continue turn answered
     # with a text): it joins that turn at its first boundary. Callable from
     # any thread; a turn that never begins keeps it for the next one, unless
@@ -344,10 +419,13 @@ module Samagotchi
     # in a --non-interactive run) and the plugin steers. At the after-answer
     # boundary the steers are dropped: the model answered, and a nudge would
     # only restart the turn. The steer part fails on its own, never taking
-    # the user's lines with it.
+    # the user's lines with it. Items are a String (a user line), a
+    # Steer::Line (a worker's input line with its sender) or a steer Hash.
     def turn_drain(pending_input)
       lambda do |at_answer: false|
         lines = pending_input ? Array(pending_input.call) : []
+        # The input went to the model: a message that waited to cut is in.
+        @waiting_steer.delivered! unless lines.empty?
         lines + take_steers(at_answer)
       end
     end
@@ -1883,6 +1961,8 @@ module Samagotchi
       # shared inactivity clock so the idle recap detector (shared with the REPL)
       # treats the just-finished turn as activity and re-arms its window.
       left = @turn_state.finish!
+      @generation_phase.finished!
+      @waiting_steer.clear!
       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,
@@ -1965,12 +2045,23 @@ module Samagotchi
       nil
     end
 
+    # Whether this generation's thinking lane said anything: nil while it
+    # streamed none, false while only whitespace (Gemma 4's empty thought
+    # with thinking off), true once a real thought came.
+    def note_generation_thought(thinking)
+      return if thinking.empty?
+
+      @generation_thought ||= thinking.match?(/\S/)
+    end
+
     # Thinking off, and the model thought anyway: logged each time, said
-    # once per session and host.
+    # once per session and host. A thinking lane of whitespace alone is no
+    # thought.
     def check_thinking_honoured(event)
       level, target = @turn_thinking
       chars = event[:thinking_chars].to_i
       return unless level == :off && chars.positive? && target
+      return if @generation_thought == false
 
       Log.warn(:model, "thinking_not_honoured", level: level, host: target.entry.name, model: target.bare_model, chars: chars)
       thinking_notice_once(:not_honoured, target, :warn,
@@ -2110,7 +2201,7 @@ module Samagotchi
       return @native_backend unless target.entry.chat?
 
       @chat_backend_mutex.synchronize do
-        @chat_backend ||= LLM::ChatLoop.new(kernel: @kernel)
+        @chat_backend ||= LLM::ChatLoop.new(kernel: @kernel, stable_length: ->(text) { @prompt_builder.stable_length(text) })
         @chat_backend.adapter = @host_registry.adapter_for(target.entry)
         @chat_backend.session_id = session&.id
         @chat_backend
@@ -2331,11 +2422,18 @@ module Samagotchi
         progress = nil
         case event[:type]
         when :generation_started
+          @generation_phase.started!
+          @generation_thought = nil
           watch&.started(event[:iteration])
         when :generation_chunk
           # A chunk without the lanes (no loop of ours sends one) counts as text.
           text = event.key?(:text) ? event[:text] : event[:content]
           progress = { thinking: event[:thinking].to_s, text: text.to_s }
+          @generation_phase.chunk!(**progress, tool_call: event[:tool_call])
+          recheck_waiting_steer unless progress[:thinking].empty?
+          note_generation_thought(progress[:thinking])
+        when :generation_retrying then @generation_phase.retrying!
+        when :generation_completed, :generation_cancelled then @generation_phase.finished!
         end
         # The chat loop asked again without the thinking fields: a notice,
         # not an event of its own.