samagotchi 0.22.0 → 0.24.0

data/lib/samagotchi/generation_phase.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # What the running generation is doing, as the Engine's stream handler
+  # sees it: whether a steer may cut it (Engine#cut_for_steer). A
+  # generation is cuttable while it has only been thinking: it streamed
+  # thinking, still streams it (a thinking delta in the last FRESH_SECONDS),
+  # and has streamed no visible text and no tool call. Its age counts from
+  # its first thinking delta, so the wait for a first token (a busy or
+  # remote server) never counts as thinking. Fed from the stream
+  # thread, read from a steer's thread: its own Mutex, never held while
+  # calling out.
+  class GenerationPhase
+    # A thinking delta this recent means the model is still thinking.
+    FRESH_SECONDS = 2.0
+
+    # @param clock [#call] monotonic seconds
+    def initialize(clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+      @clock = clock
+      @mutex = Mutex.new
+      @running = false
+      clear_seen
+    end
+
+    # A generation began.
+    def started!
+      @mutex.synchronize do
+        @running = true
+        clear_seen
+      end
+    end
+
+    # One streamed chunk's lanes. Blank text (a stray newline before Gemma's
+    # thought channel) is no text.
+    def chunk!(thinking:, text:, tool_call: false)
+      @mutex.synchronize do
+        unless thinking.to_s.empty?
+          @thinking_at = @clock.call
+          @thinking_since ||= @thinking_at
+        end
+        @text = true unless text.to_s.strip.empty?
+        @tool_call = true if tool_call
+      end
+    end
+
+    # The request is sent again (a network retry): it streams from the
+    # start, so what it had seen (its thinking clock too) is forgotten.
+    def retrying!
+      @mutex.synchronize { clear_seen }
+    end
+
+    # The generation ended (completed, cut, cancelled, or the turn ended).
+    def finished!
+      @mutex.synchronize { @running = false }
+    end
+
+    # Whether a steer may cut the running generation: thinking only, still
+    # thinking, and thinking for at least +min_age+ seconds.
+    def cuttable?(min_age)
+      @mutex.synchronize do
+        next false unless @running && @thinking_since && !@text && !@tool_call
+
+        now = @clock.call
+        now - @thinking_at <= FRESH_SECONDS && now - @thinking_since >= min_age
+      end
+    end
+
+    # Seconds since the running generation's first thinking delta; nil
+    # with none.
+    def age
+      @mutex.synchronize { @running && @thinking_since ? @clock.call - @thinking_since : nil }
+    end
+
+    private
+
+    def clear_seen
+      @thinking_since = nil
+      @thinking_at = nil
+      @text = false
+      @tool_call = false
+    end
+  end
+end

data/lib/samagotchi/guardrail_wiring.rb

@@ -159,7 +159,7 @@ module Samagotchi
               raise Guardrails::Rules::ParseError, "its sha256 differs from the installed one (edited after install? reinstall the bundle)"
             end
 
-            doc = YAML.safe_load(File.read(path))
+            doc = YAML.safe_load_file(path)
             raise Guardrails::Rules::ParseError, "expected a mapping with rules:" unless doc.is_a?(Hash)
 
             loaded.concat(Guardrails::Rules.parse(doc["rules"], source: "bundle #{bundle_name}"))

data/lib/samagotchi/guardrails/approval.rb

@@ -150,13 +150,13 @@ module Samagotchi
         return nil unless preview.is_a?(Hash)
 
         get = ->(key) { preview[key] || preview[key.to_s] }
-        return "would fail: #{get.(:error)}" if get.(:error)
-        return "not shown (#{get.(:skipped)})" if get.(:skipped)
+        return "would fail: #{get.call(:error)}" if get.call(:error)
+        return "not shown (#{get.call(:skipped)})" if get.call(:skipped)
 
-        added = get.(:added).to_i
-        return "new file, #{added} #{added == 1 ? "line" : "lines"}" if get.(:new_file)
+        added = get.call(:added).to_i
+        return "new file, #{added} #{added == 1 ? "line" : "lines"}" if get.call(:new_file)
 
-        "+#{added} −#{get.(:removed).to_i}"
+        "+#{added} −#{get.call(:removed).to_i}"
       end
     end
   end

data/lib/samagotchi/guardrails/approvals.rb

@@ -72,8 +72,8 @@ module Samagotchi
         list.find do |e|
           case e["scope"]
           when "session" then session_id && e["session_id"] == session_id && e["key"] == key
-          when "repo" then here.(e) && e["key"] == key
-          when "rule" then verdict.rule && e["rule"] == verdict.rule && e["source"] == verdict.source && here.(e)
+          when "repo" then here.call(e) && e["key"] == key
+          when "rule" then verdict.rule && e["rule"] == verdict.rule && e["source"] == verdict.source && here.call(e)
           end
         end
       end

data/lib/samagotchi/guardrails/gate.rb

@@ -120,8 +120,8 @@ module Samagotchi
       end
 
       # Registry#fire_each rescues a raising hook itself.
-      def fire_each(name, event, &after_each)
-        @hooks_lookup.call&.fire_each(name, event, &after_each)
+      def fire_each(name, event, &)
+        @hooks_lookup.call&.fire_each(name, event, &)
       end
     end
   end

data/lib/samagotchi/guardrails/read_only_shell.rb

@@ -167,7 +167,7 @@ module Samagotchi
         program = nil
         until rest.empty?
           arg = rest.shift
-          if arg == "-F" || arg == "-v" then rest.shift
+          if ["-F", "-v"].include?(arg) then rest.shift
           elsif arg.match?(/\A-[Fv]./m) then next
           elsif arg == "--" then program = rest.shift
           elsif arg.start_with?("-") then return false
@@ -296,14 +296,16 @@ module Samagotchi
           delim = @s.getch
           return false if delim.nil? || delim.match?(/[\s\\]/)
 
-          delimited(delim) && delimited(delim) && @s.skip(/[gpiImM\d]*/) && true
+          # Two calls, two fields: each one advances the scanner (pattern, then replacement).
+          delimited(delim) && delimited(delim) && @s.skip(/[gpiImM\d]*/) && true # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
         end
 
         def transliterate
           delim = @s.getch
           return false if delim.nil? || delim.match?(/[\s\\]/)
 
-          delimited(delim) && delimited(delim)
+          # Source set, then target set: each call advances the scanner.
+          delimited(delim) && delimited(delim) # rubocop:disable Lint/BinaryOperatorWithIdenticalOperands
         end
 
         # Up to the next unescaped +delim+ (consumed); false at the end.

data/lib/samagotchi/guardrails/shell_git_dirs.rb

@@ -123,7 +123,7 @@ module Samagotchi
         def expand(arg, dir)
           return nil if arg.include?(ShellLex::SUBST)
 
-          arg = arg.sub(/\A(~|\$HOME|\$\{HOME\})(?=\/|\z)/) { @home }
+          arg = arg.sub(%r{\A(~|\$HOME|\$\{HOME\})(?=/|\z)}) { @home }
           return nil if arg.include?("$") || arg.start_with?("~")
           return File.expand_path(arg) if arg.start_with?("/")
 

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -5,13 +5,23 @@ module Samagotchi
     # A small shell lexer for the guardrails' text checks (ShellGitDirs
     # and the rules' shell matchers): words with quotes and
     # backslashes undone, operators apart, comments dropped, and $(…) or
-    # backticks (quoted or not) as one opaque SUBST marker inside a word. It never runs
-    # anything, and it does its best on odd input (an unbalanced quote).
+    # backticks (quoted or not) as one opaque SUBST marker inside a word. A
+    # heredoc's body (<<EOF, <<'EOF', <<-EOF) is one word after its <<TAG
+    # word and lexing goes on after the terminator line: HEREDOC when cat or
+    # tee read it as data, SUBST when an unquoted tag's body holds $(…) or
+    # backticks, else the body text itself (a script, as sh -c '…' gives).
+    # An unterminated heredoc is no heredoc: the rest is lexed as commands.
+    # It never runs anything, and it does its best on odd input (an
+    # unbalanced quote).
     module ShellLex
       # Longest first: "&&" before "&", ";;" before ";".
       OPERATORS = ["&&", "||", ";;", "|&", ";", "|", "&", "\n", "(", ")"].freeze
       # What a $(…) or `…` becomes inside a word.
       SUBST = "\0SUBST"
+      # What a heredoc body that cat or tee read as data becomes.
+      HEREDOC = "\0HEREDOC"
+      # Commands that read a heredoc as data (when not piped on).
+      DATA_SINKS = %w[cat tee].freeze
       # A word that is a redirection (>, >>, 2>&1, <).
       REDIRECT = /\A\d*[<>]/
 
@@ -50,6 +60,7 @@ module Samagotchi
           @word = +""
           @specials = +""
           @in_word = false
+          @heredocs = []
         end
 
         def tokens
@@ -139,15 +150,19 @@ module Samagotchi
           @i = @s.index("\n", @i) || @s.size
         end
 
-        # >, >>, 2>&1, &>, <, <<: kept in the word (the walk drops them).
+        # >, >>, 2>&1, &>, <, <<<: kept in the word (the walk drops them).
+        # << starts a heredoc.
         def redirection
+          return add("<<<", 3) if @s[@i, 3] == "<<<"
+          return if @s[@i, 2] == "<<" && heredoc
+
           special(@s[@i])
-          add(@s[@i], 1) while @i < @s.size && @s[@i].match?(/[&\d>-]/) && @word.match?(/>\z/)
+          add(@s[@i], 1) while @i < @s.size && @s[@i].match?(/[&\d>-]/) && @word.end_with?(">")
         end
 
         def operator_or_char(char)
           op = OPERATORS.find { |o| @s[@i, o.size] == o }
-          return special(char) if char == "{" || char == "}"
+          return special(char) if ["{", "}"].include?(char)
           return add(char, 1) unless op
 
           if op == "&" && @word.match?(/\d*>\z/)
@@ -156,8 +171,101 @@ module Samagotchi
             flush
             @tokens << [:op, op]
             @i += op.size
+            bodies if op == "\n" && !@heredocs.empty?
           end
         end
+
+        # <<TAG, <<-TAG, <<'TAG', << "TAG": its own word, the body noted to
+        # be read after the line ends. False (nothing read) without a tag.
+        def heredoc
+          dash = @s[@i + 2] == "-"
+          j = @i + (dash ? 3 : 2)
+          j += 1 while [" ", "\t"].include?(@s[j])
+          tag, quoted, stop = heredoc_tag(j)
+          return false if tag.empty?
+
+          flush unless @word.match?(/\A\d*\z/)
+          special("<")
+          @word << "<" << (dash ? "-" : "") << tag
+          @i = stop
+          flush
+          @heredocs << { tag: tag, dash: dash, quoted: quoted, at: @tokens.size }
+          true
+        end
+
+        # The tag starting at +j+ with quotes and backslashes undone, whether
+        # any were there, and where it ends.
+        def heredoc_tag(j)
+          tag = +""
+          quoted = false
+          while j < @s.size && !@s[j].match?(/[\s;&|<>()]/)
+            if ["'", '"'].include?(@s[j])
+              close = @s.index(@s[j], j + 1) or return ["", false, j]
+              tag << @s[(j + 1)...close]
+              j = close + 1
+              quoted = true
+            elsif @s[j] == "\\"
+              tag << @s[j + 1].to_s
+              j += 2
+              quoted = true
+            else
+              tag << @s[j]
+              j += 1
+            end
+          end
+          [tag, quoted, j]
+        end
+
+        # After a line with heredocs: each body in order, up to its
+        # terminator line, as one word in its command. Unterminated: none
+        # are, and the rest is lexed as commands.
+        def bodies
+          heredocs = @heredocs
+          @heredocs = []
+          pos = @i
+          read = []
+          heredocs.each do |doc|
+            body, pos = body(doc, pos)
+            break unless body
+
+            read << [doc, body]
+          end
+          return if read.size < heredocs.size
+
+          read.reverse_each { |doc, body| @tokens.insert(doc[:at], [:word, body_word(doc, body), ""]) }
+          @i = pos
+        end
+
+        # The body from +pos+ and where lexing goes on, or nil.
+        def body(doc, pos)
+          start = pos
+          while pos < @s.size
+            eol = @s.index("\n", pos) || @s.size
+            line = @s[pos...eol]
+            line = line.sub(/\A\t+/, "") if doc[:dash]
+            return [@s[start...pos], [eol + 1, @s.size].min] if line == doc[:tag]
+
+            pos = eol + 1
+          end
+          nil
+        end
+
+        def body_word(doc, body)
+          return SUBST if !doc[:quoted] && body.match?(/\$\(|`/)
+          return HEREDOC if data_sink?(doc[:at])
+
+          body
+        end
+
+        # Whether the command the heredoc at token +at+ is in is cat or tee
+        # and not piped into another command.
+        def data_sink?(at)
+          start = at
+          start -= 1 while start.positive? && @tokens[start - 1][0] == :word
+          verb = @tokens[start...at].map { |t| t[1] }.find { |w| !w.match?(/\A[A-Za-z_]\w*=/) && !w.match?(REDIRECT) }
+          next_op = @tokens[at..].find { |t| t[0] == :op }
+          DATA_SINKS.include?(File.basename(verb.to_s)) && !["|", "|&"].include?(next_op&.dig(1))
+        end
       end
     end
   end

data/lib/samagotchi/guardrails/shell_paths.rb

@@ -107,14 +107,14 @@ module Samagotchi
         def candidate(word)
           word = word.sub(REDIRECT_PREFIX, "")
           word = word.split("=", 2).last if word.match?(/\A(--?[\w-]+|[A-Za-z_]\w*)=/)
-          return nil if word.empty? || word == "-" || word.match?(/\A-[^\/]/)
+          return nil if word.empty? || word == "-" || word.match?(%r{\A-[^/]})
 
           word
         end
 
         # An absolute path for +word+ against +dir+, or nil.
         def resolve(word, dir)
-          return nil if word.include?(ShellLex::SUBST) || word.match?(SCRIPT)
+          return nil if word.include?(ShellLex::SUBST) || word == ShellLex::HEREDOC || word.match?(SCRIPT)
 
           word = expand(word) or return nil
           return nil if word.match?(GLOB)
@@ -124,7 +124,7 @@ module Samagotchi
         end
 
         def expand(word)
-          word = word.sub(/\A~(?=\/|\z)/) { @home }
+          word = word.sub(%r{\A~(?=/|\z)}) { @home }
           word = word.sub(EXPANSION) { value(Regexp.last_match(1) || Regexp.last_match(2)) || "$" }
           return nil if word.include?("$") || word.start_with?("~")
 

data/lib/samagotchi/hooks/bundle_loader.rb

@@ -65,13 +65,13 @@ module Samagotchi
             next if basename.empty?
 
             meta = ->(key) { raw_meta && (raw_meta[key] || raw_meta[key.to_s]) }
-            event = meta.(:event).to_s
+            event = meta.call(:event).to_s
             # A hook with no declared event cannot be auto-registered.
             next if event.empty?
 
             event_sym = event.to_sym
-            on_error = (meta.(:on_error) || "skip").to_s
-            priority = (meta.(:priority) || 100).to_i
+            on_error = (meta.call(:on_error) || "skip").to_s
+            priority = (meta.call(:priority) || 100).to_i
             fail_closed = on_error == "fail_closed" && event_sym == :before_tool_call
             what = "hook #{basename} (bundle #{bundle_name})"
             file = hooks_dir && File.join(hooks_dir, basename)
@@ -79,7 +79,7 @@ module Samagotchi
               failures&.add(what, "the file is missing", required: true) if fail_closed
               next
             end
-            if (mismatch = too_old || sha_mismatch(file, meta.(:sha256), required: fail_closed))
+            if (mismatch = too_old || sha_mismatch(file, meta.call(:sha256), required: fail_closed))
               Log.warn(:hooks, "bundle_hook_mismatch", echo: "[samagotchi:hooks] bundle '#{bundle_name}' hook '#{basename}' not loaded: #{mismatch}", bundle: bundle_name, hook: basename.to_s)
               failures&.add(what, mismatch, required: fail_closed)
               next
@@ -91,12 +91,14 @@ module Samagotchi
                        elsif on_error == "log" then :log
                        else :skip
                        end
-              label = "#{fail_closed ? "guardrail " : ""}#{basename} (bundle #{bundle_name})"
+              label = "#{"guardrail " if fail_closed}#{basename} (bundle #{bundle_name})"
               handler = Hooks.wrap(label: label, event: event_sym, policy: policy, log: [:hooks, "bundle_hook_failed"],
                                    fields: { bundle: bundle_name }) { |event| plugin.call(event) }
               registry.register_bundle(bundle_name, event_sym, hook_name: basename, priority: priority, &handler)
               loaded += 1
-            rescue Exception => e
+            rescue Exception => e # rubocop:disable Lint/RescueException -- a hook's SyntaxError or exit must not stop chi
+              raise if e.is_a?(SignalException) # Ctrl-C and kill signals are the user's
+
               Log.error(:hooks, "bundle_hook_load_failed", echo: "[samagotchi:hooks] bundle '#{bundle_name}' hook '#{basename}' failed to load: #{e.class}: #{e.message}", bundle: bundle_name, hook: basename.to_s, error: e.class.name)
               failures&.add(what, "#{e.class}: #{e.message}", required: fail_closed)
             end
@@ -127,6 +129,7 @@ module Samagotchi
           klass = Hooks.class_for(basename, ns)
           instance = Hooks.build_plugin(klass, settings)
           raise ArgumentError, "plugin #{klass.name.split("::").last} does not respond to #call" unless instance.respond_to?(:call)
+
           instance
         end
 

data/lib/samagotchi/hooks/loader.rb

@@ -67,17 +67,15 @@ module Samagotchi
           definitions = parse_definitions(hooks_config)
 
           definitions.each do |defn|
-            begin
-              plugin = load_plugin(hooks_dir, defn[:path], settings: defn[:settings])
-              # Persistent: config hooks must fire on every turn, not be wiped
-              # by Engine#run_turn's per-turn clear_hooks after turn 1.
-              registry.register_persistent(defn[:event_type].to_sym, label: "#{defn[:path]} (config)",
-                                           &wrapped(plugin, defn))
-            rescue ScriptError, StandardError => e
-              # ScriptError: a SyntaxError (or LoadError) from `require`.
-              Log.error(:hooks, "hook_load_failed", echo: "[samagotchi:hooks] hook #{defn[:path]} failed to load: #{e.class}: #{e.message}", hook: defn[:path].to_s, error: e.class.name)
-              failures&.add("hook #{defn[:path]} (config)", "#{e.class}: #{e.message}", required: defn[:required])
-            end
+            plugin = load_plugin(hooks_dir, defn[:path], settings: defn[:settings])
+            # Persistent: config hooks must fire on every turn, not be wiped
+            # by Engine#run_turn's per-turn clear_hooks after turn 1.
+            registry.register_persistent(defn[:event_type].to_sym, label: "#{defn[:path]} (config)",
+                                         &wrapped(plugin, defn))
+          rescue ScriptError, StandardError => e
+            # ScriptError: a SyntaxError (or LoadError) from `require`.
+            Log.error(:hooks, "hook_load_failed", echo: "[samagotchi:hooks] hook #{defn[:path]} failed to load: #{e.class}: #{e.message}", hook: defn[:path].to_s, error: e.class.name)
+            failures&.add("hook #{defn[:path]} (config)", "#{e.class}: #{e.message}", required: defn[:required])
           end
 
           registry
@@ -87,6 +85,7 @@ module Samagotchi
       # Expand a path that may start with ~.
       def self.expand_path(path, env = ENV)
         return path unless path.start_with?("~")
+
         home = env["HOME"] || Dir.home
         File.join(home, path[1..])
       end
@@ -97,8 +96,10 @@ module Samagotchi
         definitions = []
         hooks_config.each do |event_type, configs|
           next unless event_type.to_s != "hooks_dir" && configs.is_a?(Array)
+
           configs.each do |cfg|
             next unless cfg.is_a?(Hash) && cfg["path"]
+
             definitions << {
               event_type: event_type.to_s,
               path: cfg["path"],
@@ -123,9 +124,7 @@ module Samagotchi
 
         # Check if already loaded (Ruby's require caching handles this)
         # We cache the instance separately to avoid re-instantiating
-        unless @plugin_cache
-          @plugin_cache = {}
-        end
+        @plugin_cache ||= {}
 
         @plugin_cache[[full_path, settings]] ||= begin
           require full_path
@@ -133,6 +132,7 @@ module Samagotchi
           instance = Hooks.build_plugin(klass, settings)
           # Validate that the instance responds to #call
           raise ArgumentError, "Plugin #{klass.name} does not respond to #call" unless instance.respond_to?(:call)
+
           instance
         end
       end
@@ -142,9 +142,11 @@ module Samagotchi
       # on_error: log warns and skip is silent.
       def self.wrapped(plugin, defn)
         if defn[:required] && defn[:event_type] == "before_tool_call"
-          policy, label = :deny, "required hook #{defn[:path]}"
+          policy = :deny
+          label = "required hook #{defn[:path]}"
         else
-          policy, label = (defn[:on_error] == "log" ? :log : :skip), "#{defn[:path]} (config)"
+          policy = (defn[:on_error] == "log" ? :log : :skip)
+          label = "#{defn[:path]} (config)"
         end
         Hooks.wrap(label: label, event: defn[:event_type].to_sym, policy: policy) { |event| plugin.call(event) }
       end

data/lib/samagotchi/hooks/registry.rb

@@ -13,7 +13,11 @@ module Samagotchi
     # @param settings [Hash]
     def self.build_plugin(klass, settings)
       takes_settings = klass.instance_method(:initialize).arity != 0
-      takes_settings ? klass.new(settings.is_a?(Hash) ? settings : {}) : klass.new
+      if takes_settings
+        klass.new(settings.is_a?(Hash) ? settings : {})
+      else
+        klass.new
+      end
     end
 
     # A stream hook (:generation_progress) fires ~once a second: a broken
@@ -62,7 +66,7 @@ module Samagotchi
     def self.wrap(label:, event:, policy:, log: [:hooks, "hook_failed"], echo: true, fields: {}, &block)
       log_failure = failure_log_gate(event)
       lambda do |payload|
-        block.call(payload)
+        yield(payload)
       rescue Exception => e # rubocop:disable Lint/RescueException -- :deny fails closed on anything
         raise unless policy == :deny || e.is_a?(StandardError) || e.is_a?(ScriptError)
 
@@ -130,6 +134,7 @@ module Samagotchi
       def register(name, &block)
         raise ArgumentError, "hook name must be a Symbol" unless name.is_a?(Symbol)
         raise ArgumentError, "hook block is required" unless block_given?
+
         @mutex.synchronize { (@hooks[name] ||= []) << block }
       end
 
@@ -144,6 +149,7 @@ module Samagotchi
       def register_persistent(name, label: nil, &block)
         raise ArgumentError, "hook name must be a Symbol" unless name.is_a?(Symbol)
         raise ArgumentError, "hook block is required" unless block_given?
+
         label = label.to_s.strip
         label = CONFIG_HOOK_LABEL if label.empty?
         @mutex.synchronize { (@persistent_hooks[name] ||= []) << { label: label, proc: block } }
@@ -160,6 +166,7 @@ module Samagotchi
       # @return [void]
       def register_bundle(bundle_name, event_name, hook_name:, priority: 100, &block)
         raise ArgumentError, "hook block is required" unless block_given?
+
         @mutex.synchronize do
           (@bundle_hooks[event_name] ||= []) << {
             bundle: bundle_name,
@@ -180,6 +187,7 @@ module Samagotchi
           if event_name
             arr = @bundle_hooks[event_name]
             return 0 unless arr
+
             before = arr.size
             @bundle_hooks[event_name] = arr.reject { |h| h[:bundle] == bundle_name }
             removed = before - @bundle_hooks[event_name].size

data/lib/samagotchi/host_registry.rb

@@ -118,9 +118,7 @@ module Samagotchi
       @model_index = nil # downcased model_id => [host_name] in hosts: order
     end
 
-    def entries
-      @entries
-    end
+    attr_reader :entries
 
     # Loopback, private (RFC 1918, IPv6 unique local) and link-local nets.
     LOCAL_NETS = %w[127.0.0.0/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 169.254.0.0/16 100.64.0.0/10

data/lib/samagotchi/idle_recap.rb

@@ -46,7 +46,7 @@ module Samagotchi
     module TranscriptFilter
       # A tool call as the model wrote it inline: gemma, qwen, or the qwen
       # prompt-literal form. An unterminated gemma call runs to the end.
-      TOOL_CALL_RE = /<\|tool_call>(?:.*?<tool_call\|>|.*\z)|<tool_call>.*?<\/tool_call>|\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_OPEN\]\].*?\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_CLOSE\]\]/m
+      TOOL_CALL_RE = %r{<\|tool_call>(?:.*?<tool_call\|>|.*\z)|<tool_call>.*?</tool_call>|\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_OPEN\]\].*?\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_CLOSE\]\]}m
       # Each dispatched call's output starts with "[name]"; the kernel loop
       # joins one step's outputs into a single tool_response with this
       # separator, while the chat loop writes one message per call.
@@ -63,8 +63,10 @@ module Samagotchi
 
           case message["role"]
           when "user"
-            # A plugin's steer is a prod to the model, not what the user said.
-            next nil if Steer.steer?(message)
+            # A plugin's steer is a prod to the model, not what the user said;
+            # a continue steer from the user or the parent agent is an
+            # instruction, kept.
+            next nil if Steer.steer?(message) && !Steer.person?(message)
 
             # An image is a line naming it (refs only, never its bytes), unless
             # the text is only the web's placeholder naming it already.
@@ -215,7 +217,7 @@ module Samagotchi
         system = format(SYSTEM, range) + (previous ? UPDATE + format(UPDATE_LENGTH, range) : "") + tools
         user = +""
         user << "Earlier recap:\n#{previous}\n\n" if previous
-        user << "Transcript#{previous ? ' since the earlier recap' : ''} (the system prompt and tool " \
+        user << "Transcript#{" since the earlier recap" if previous} (the system prompt and tool " \
                 "internals were removed; only user turns and assistant prose remain):\n---\n#{body}\n---\n"
         user << "#{OFFER_LINE}\n" if offer
         user << "Write the recap now."
@@ -225,7 +227,7 @@ module Samagotchi
       # "2-4 sentences", or "3 sentences" for [3, 3] ("1 sentence" for [1, 1])
       def sentences_text((min, max), adjective = "")
         count = min == max ? min.to_s : "#{min}-#{max}"
-        "#{count} #{adjective}#{max == 1 ? 'sentence' : 'sentences'}"
+        "#{count} #{adjective}#{max == 1 ? "sentence" : "sentences"}"
       end
 
       # The tail of +body+ when it is over MAX_NEW_CHARS, from a paragraph
@@ -243,7 +245,7 @@ module Samagotchi
       def tools_used(names)
         return "" if names.empty?
 
-        " (#{names.tally.map { |name, n| n > 1 ? "#{name} x#{n}" : name }.join(', ')})"
+        " (#{names.tally.map { |name, n| n > 1 ? "#{name} x#{n}" : name }.join(", ")})"
       end
     end
 
@@ -395,6 +397,17 @@ module Samagotchi
       @engine.activity_seq > @last_fire_activity_seq
     end
 
+    # SHA1 of one message's role and text: detects a rewrite a count alone
+    # misses. Model text is taken without its thinking, which is dropped from
+    # older model messages when the next turn starts.
+    def self.digest(message)
+      return nil unless message.is_a?(Hash)
+
+      text = message["content"].to_s
+      text = TranscriptFilter.strip_thought(text) if %w[model assistant].include?(message["role"])
+      Digest::SHA1.hexdigest("#{message["role"]}\0#{text}")
+    end
+
     private
 
     # A failing check writes the recap without the offer line.
@@ -431,9 +444,11 @@ module Samagotchi
       # Nothing new said (only notes, tool traffic, or no messages at all):
       # the recap still stands, so no request.
       return :nothing_new if transcript.strip.empty?
+
       prompt = RecapPrompt.build(transcript, tool_names: TranscriptFilter.tool_names(fresh), previous: previous&.dig(:text),
                                                      sentences: @sentences, offer: offer_open?)
       return :nothing_new if prompt.nil?
+
       asked = target
       @in_flight = { thread: spawn_summarize(client_for(asked), prompt), generation: gen, deadline: @clock.call + @timeout,
                      covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked[:label] }
@@ -459,6 +474,7 @@ module Samagotchi
       @in_flight = nil
       recap = safe_value(job[:thread])
       return if recap.nil? || recap.to_s.strip.empty?
+
       # An IdleClient::Summary names the model that answered; a plain String
       # (a stubbed client) doesn't, and the asked label stands in.
       served = recap.model if recap.respond_to?(:model)
@@ -503,17 +519,6 @@ module Samagotchi
       saved
     end
 
-    # SHA1 of one message's role and text: detects a rewrite a count alone
-    # misses. Model text is taken without its thinking, which is dropped from
-    # older model messages when the next turn starts.
-    def self.digest(message)
-      return nil unless message.is_a?(Hash)
-
-      text = message["content"].to_s
-      text = TranscriptFilter.strip_thought(text) if %w[model assistant].include?(message["role"])
-      Digest::SHA1.hexdigest("#{message['role']}\0#{text}")
-    end
-
     def bump_generation
       @mutex.synchronize { @generation += 1 }
     end