samagotchi 0.22.0 → 0.24.0

data/lib/samagotchi/commands/registry.rb

@@ -80,7 +80,7 @@ module Samagotchi
       # 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/
+      UNKNOWN_COMMAND_WORD = %r{\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.
@@ -100,7 +100,7 @@ module Samagotchi
 
         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."
+        "Unknown command #{text}. #{"Did you mean #{close}? " if close}/help lists the commands."
       end
 
       # @return [Entry, nil] the first entry the UI runs itself (local) that

data/lib/samagotchi/config.rb

@@ -4,7 +4,6 @@ require "yaml"
 require "json"
 require "fileutils"
 require "uri"
-require "set"
 require_relative "atomic_file"
 require_relative "config_text_edit"
 require_relative "log"
@@ -56,8 +55,8 @@ module Samagotchi
     end
 
     # Section names: lower alnum only, no _ or -.
-    SECTION_RE = /\A[a-z0-9]+\z/.freeze
-    LEAF_RE    = /\A[a-z0-9_]+\z/.freeze
+    SECTION_RE = /\A[a-z0-9]+\z/
+    LEAF_RE    = /\A[a-z0-9_]+\z/
 
     ENTRIES = [
       # universal – env+config+cli
@@ -126,7 +125,7 @@ module Samagotchi
       Entry.new(key: "context.status",           yaml_path: %w[context status],           type: :bool,   default: true,             expose: %i[env config cli]),
       Entry.new(key: "context.window_tokens",    yaml_path: %w[context window_tokens],    type: :integer, default: nil,             expose: %i[env config cli]),
       Entry.new(key: "context.chars_per_token",  yaml_path: %w[context chars_per_token],  type: :float,   default: 4.0,             expose: %i[env config cli]),
-      Entry.new(key: "context.status_thresholds", yaml_path: %w[context status_thresholds],type: :string, default: "20,40,60,80",    expose: %i[env config cli]),
+      Entry.new(key: "context.status_thresholds", yaml_path: %w[context status_thresholds], type: :string, default: "20,40,60,80",    expose: %i[env config cli]),
       Entry.new(key: "context.status_cadence",   yaml_path: %w[context status_cadence],   type: :integer, default: 0,               expose: %i[env config cli]),
 
       Entry.new(key: "thinking.turn_preamble",   yaml_path: %w[thinking turn_preamble],   type: :bool,   default: true,             expose: %i[env config cli]),
@@ -136,7 +135,7 @@ module Samagotchi
       # the flag and the env, above config.yml's value.
       Entry.new(key: "thinking.level",           yaml_path: %w[thinking level],           type: :string, default: "default",       expose: %i[env config]),
 
-      Entry.new(key: "default.n_predict",        yaml_path: %w[default n_predict],        type: :integer, default: nil,              expose: %i[env config cli]),
+      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]),
 
       Entry.new(key: "retry.max",                yaml_path: %w[retry max],                type: :integer, default: 5,               expose: %i[env config cli]),
@@ -145,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]),
@@ -186,7 +189,7 @@ module Samagotchi
       # env+config only
       Entry.new(key: "default.input",            yaml_path: %w[default input],            type: :string, default: nil,              expose: %i[env config]),
       Entry.new(key: "history.file",             yaml_path: %w[history file],             type: :string, default: nil,              expose: %i[env config]),
-      Entry.new(key: "skip_agent_md",            yaml_path: %w[skip_agent_md],            type: :bool,   default: false,            expose: %i[env config]),
+      Entry.new(key: "skip_agent_md",            yaml_path: %w[skip_agent_md],            type: :bool,   default: false,            expose: %i[env config])
     ].freeze
 
     # Top-level maps read by their own code, whose entry names and contents
@@ -228,11 +231,13 @@ module Samagotchi
       # Coercion helpers
       def coerce(entry, raw)
         return nil if raw.nil?
+
         # For string, preserve as-is (including trailing spaces like "Please ")
         if entry.type == :string
           # A YAML list for a "|"-separated setting (web.annotate_presets).
           str = raw.is_a?(Array) ? raw.join("|") : raw.to_s
           return nil if str.empty? && entry.type != :string
+
           return str
         end
         str = raw.to_s.strip
@@ -267,7 +272,7 @@ module Samagotchi
           lowered = str.downcase
           allowed = entry.enum_values.map(&:downcase)
           unless allowed.include?(lowered)
-            Log.warn(:config, "invalid_value", echo: "Warning: invalid value for #{entry.key}: #{raw.inspect} (allowed: #{entry.enum_values.join(', ')}) — using default", key: entry.key)
+            Log.warn(:config, "invalid_value", echo: "Warning: invalid value for #{entry.key}: #{raw.inspect} (allowed: #{entry.enum_values.join(", ")}) — using default", key: entry.key)
             return entry.default
           end
           # return canonical casing from enum_values
@@ -296,6 +301,7 @@ module Samagotchi
           raw = cli_overrides[entry.key]
           # cli_overrides may already be coerced; detect by type
           return [raw, :cli] if already_coerced?(entry, raw)
+
           return [coerce(entry, raw), :cli]
         end
         if cli_overrides.key?(entry.cli_flag)
@@ -323,7 +329,7 @@ module Samagotchi
 
       def already_coerced?(entry, val)
         case entry.type
-        when :bool then val == true || val == false
+        when :bool then [true, false].include?(val)
         when :integer then val.is_a?(Integer)
         when :float then val.is_a?(Float) || val.is_a?(Integer)
         when :enum then entry.enum_values.include?(val)
@@ -343,6 +349,7 @@ module Samagotchi
         cur = data
         yaml_path.each_with_index do |seg, idx|
           return nil unless cur.is_a?(Hash)
+
           last = idx == yaml_path.size - 1
           if last
             candidates = [seg, seg.to_sym]
@@ -361,6 +368,7 @@ module Samagotchi
             # also try kebab alias for section (should not exist per spec, but be lenient)
             nxt ||= cur[seg.tr("_", "-")] || cur[seg.tr("_", "-").to_sym]
             return nil if nxt.nil?
+
             cur = nxt
           end
         end
@@ -404,6 +412,13 @@ module Samagotchi
         get_with_origin(key).first
       end
 
+      # default.max_tokens: the most tokens one generation may produce, or
+      # nil when unset or not positive (the server's own limit).
+      def max_tokens
+        value = get("default.max_tokens").to_i
+        value if value.positive?
+      end
+
       # A timeout setting (server.open_timeout, server.read_timeout) in
       # seconds, +given+ (a caller's own value) first; one that isn't
       # positive (0, a word) is the key's default, on every kind of host.
@@ -419,6 +434,7 @@ module Samagotchi
       def get_with_origin(key)
         entry = find_by_key(key)
         raise ArgumentError, "unknown config key: #{key}" unless entry
+
         # Live resolve so ENV changes (as in specs) are reflected without explicit reload
         # Use current ENV and file (via ConfigFile's cached reader), plus any CLI
         # overrides captured via reload!
@@ -546,7 +562,7 @@ module Samagotchi
         candidates = candidates.uniq
         near = near_names(probe, candidates)
         close = (near + candidates.select { |c| c.split(".").last == probe.split(".").last }).uniq.first(3)
-        hint = close.empty? ? "" : " (did you mean #{close.map { |c| "'#{prefix}#{c}'" }.join(' or ')}?)"
+        hint = close.empty? ? "" : " (did you mean #{close.map { |c| "'#{prefix}#{c}'" }.join(" or ")}?)"
         "config: unknown key '#{key}'#{hint}"
       end
 
@@ -582,6 +598,7 @@ module Samagotchi
     # parsed Hash or nil (missing file / parse error / non-mapping top level).
     def read_yaml(env: ENV, path: global_path(env: env))
       return nil if path.nil?
+
       cache = @yaml_cache ||= {}
       unless File.file?(path)
         cache.delete(path)
@@ -593,7 +610,7 @@ module Samagotchi
       return hit[1] if hit && hit[0] == key
 
       data = begin
-        YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+        YAML.safe_load_file(path, permitted_classes: [], aliases: false)
       rescue StandardError
         nil
       end
@@ -631,7 +648,7 @@ module Samagotchi
     # else warns once and counts as unset.
     def bool_flag(value, where, key)
       return nil if value.nil?
-      return value if value == true || value == false
+      return value if [true, false].include?(value)
 
       text = value.to_s.strip.downcase
       return true if text == "true"
@@ -653,6 +670,7 @@ module Samagotchi
     # nil. Reserved keys warn once and are dropped. nil when nothing is left.
     def sampling_map(value, where)
       return nil if value.nil?
+
       unless value.is_a?(Hash)
         warn_once "Warning: #{where}: sampling must be a map of request parameters; ignored"
         return nil
@@ -661,6 +679,7 @@ module Samagotchi
       result = value.each_with_object({}) do |(raw_key, raw_value), acc|
         key = raw_key.to_s.strip
         next if key.empty?
+
         if SAMPLING_RESERVED_KEYS.include?(key)
           warn_once "Warning: #{where}: sampling.#{key} is set by chi; ignored"
           next
@@ -687,6 +706,7 @@ module Samagotchi
     def clear_yaml_cache!(path = nil)
       cache = @yaml_cache
       return if cache.nil?
+
       if path
         cache.delete(path)
       else
@@ -734,6 +754,7 @@ module Samagotchi
         raw_hosts.each do |raw_name, raw_cfg|
           name = raw_name.to_s.strip
           next if name.empty?
+
           unless name.match?(HOST_NAME_RE)
             warn_once "Warning: ignoring hosts entry '#{name}': must match /[a-z0-9][a-z0-9._-]*/i"
             next
@@ -795,7 +816,7 @@ module Samagotchi
             next
           end
           port_val = port.to_s.strip.empty? ? 8080 : port.to_i
-          if port_val <= 0 || port_val > 65535
+          if port_val <= 0 || port_val > 65_535
             warn_once "Warning: ignoring hosts entry '#{name}': invalid port"
             next
           end
@@ -835,7 +856,7 @@ module Samagotchi
         default_host = Samagotchi::Config.resolve("server.host", **opts).to_s.strip
         default_host = "localhost" if default_host.empty?
         default_port = Samagotchi::Config.resolve("server.port", **opts).to_i
-        default_port = 8080 if default_port <= 0 || default_port > 65535
+        default_port = 8080 if default_port <= 0 || default_port > 65_535
         transport_sym = Samagotchi::Config.resolve_with_origin("server.transport", **opts).then do |value, origin|
           origin == :default ? nil : value.to_sym
         end
@@ -877,7 +898,11 @@ module Samagotchi
 
     # enabled: false (or "false", any case) in a hosts entry.
     def host_disabled?(cfg)
-      enabled = cfg.key?("enabled") ? cfg["enabled"] : (cfg.key?(:enabled) ? cfg[:enabled] : true)
+      enabled = if cfg.key?("enabled")
+                  cfg["enabled"]
+                else
+                  (cfg.key?(:enabled) ? cfg[:enabled] : true)
+                end
       enabled == false || enabled.to_s.strip.downcase == "false"
     end
     private_class_method :host_disabled?
@@ -959,6 +984,7 @@ module Samagotchi
       # Only serialize if non-default or explicitly configured hosts:
       # include when hosts file exists with hosts: section or when workers need propagation
       return nil if hosts.nil? || hosts.empty?
+
       # Serialize to JSON with string keys
       simple = hosts.transform_values do |v|
         # A url entry travels as its url (host/port come from it); the API
@@ -990,6 +1016,7 @@ module Samagotchi
     def bundle_settings(env: ENV, path: global_path(env: env))
       raw = section("bundles", env: env, path: path)
       return {} if raw.nil?
+
       unless raw.is_a?(Hash)
         Log.warn(:hooks, "bundles_section_invalid", echo: "[samagotchi:hooks] config.yml bundles: must be a mapping of bundle name to settings; ignored")
         return {}
@@ -1025,6 +1052,7 @@ module Samagotchi
       raw.each_with_object({}) do |(k, v), result|
         key = k.to_s.strip
         next if key.empty?
+
         val = v.to_s.strip
         next if val.empty?
 

data/lib/samagotchi/context_note.rb

@@ -42,7 +42,7 @@ module Samagotchi
 
     # The note's own text, without its frame.
     def text_of(message)
-      fetch(message, :content).to_s.sub(/\A\[CONTEXT NOTE[^\n]*\n/, "").sub(/\n\[END NOTE\]\z/, "")
+      fetch(message, :content).to_s.sub(/\A\[CONTEXT NOTE[^\n]*\n/, "").delete_suffix("\n[END NOTE]")
     end
 
     def fetch(message, key)

data/lib/samagotchi/context_status.rb

@@ -64,7 +64,7 @@ module Samagotchi
     def self.last_bucket(conversation)
       message = conversation.reverse.find do |entry|
         content = entry[:content].to_s
-        entry[:role] == "system" && (content.start_with?(STATUS_PREFIX) || content.start_with?(LINE_PREFIX))
+        entry[:role] == "system" && content.start_with?(STATUS_PREFIX, LINE_PREFIX)
       end
       return nil unless message
 
@@ -221,11 +221,11 @@ module Samagotchi
     end
 
     def emit?(bucket:, iteration_index:)
-      bucket_changed = if @last_bucket.nil?
-                         bucket != "under#{@thresholds.first}"
-                       else
-                         bucket != @last_bucket
-                       end
+      bucket_changed = bucket != if @last_bucket.nil?
+                                   "under#{@thresholds.first}"
+                                 else
+                                   @last_bucket
+                                 end
       cadence_due = @cadence.positive? && ((iteration_index + 1) % @cadence).zero?
       bucket_changed || cadence_due
     end

data/lib/samagotchi/continue_offer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "time"
+require_relative "log"
 
 module Samagotchi
   # A session worker's continue offer: what it announces when a turn runs out
@@ -55,9 +56,9 @@ module Samagotchi
     # (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
+      return unless %i[continue_offered continue_cancelled].include?(outcome)
 
-      open
+      announce_offer
     end
 
     # A prompt (or a reminder turn) taken while a continue is offered
@@ -111,20 +112,26 @@ module Samagotchi
     # 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. The answer's text is carried into the turn as it begins;
-    # a turn that never began (a raise before it) leaves it to no other.
+    # asks again, one before the turn began too (logged, no :turn_failed).
+    # The answer's text is carried into the turn as it begins; a turn that
+    # never began leaves it to no other.
     def run_continue_turn(command)
       offer = @turn_flow.offer
       close("answered")
       steer = @continue_steer
       @continue_steer = nil
       begin
-        @engine.steer_next_turn(steer[:text], source: steer[:source]) if steer
-        @turn_flow.before_continue_turn
+        begin
+          @engine.steer_next_turn(steer[:text], source: steer[:source]) if steer
+          @turn_flow.before_continue_turn
+        rescue StandardError => e
+          Log.warn(:worker, "turn_not_begun", continue: true, error: e.class.name, msg: e.message)
+          return announce_offer(offer)
+        end
         @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)
+            announce_offer(offer)
           else
             after_turn(result, continue: true, no_interrupt: offer[:no_interrupt])
           end
@@ -145,7 +152,7 @@ module Samagotchi
 
     private
 
-    def open(offer = @turn_flow.offer)
+    def announce_offer(offer = @turn_flow.offer)
       @engine.announce(type: :continue_offered, context: offer[:context], no_interrupt: offer[:no_interrupt])
       ask
     end

data/lib/samagotchi/debug_log.rb

@@ -86,7 +86,7 @@ module Samagotchi
 
     def rotate
       File.open("#{@path}.lock", File::RDWR | File::CREAT, 0o600) do |lock|
-        return unless lock.flock(File::LOCK_EX | File::LOCK_NB)
+        next unless lock.flock(File::LOCK_EX | File::LOCK_NB)
 
         stat = File.stat(@path)
         File.rename(@path, "#{@path}.1") if stat.ino == @ino && stat.size >= @max_bytes

data/lib/samagotchi/desktop/macos.rb

@@ -22,7 +22,8 @@ module Samagotchi
     # command goes through the runner, and the dirs are injectable, so specs
     # (and smokes with register: false) never touch the real system.
     class MacOS
-      Error = Class.new(StandardError)
+      class Error < StandardError
+      end
 
       APP_NAME = "Chi Helper"
       BUNDLE_ID = "dev.samagotchi.chi-helper"
@@ -166,9 +167,9 @@ module Samagotchi
       end
 
       # Keeps the login item as it was.
-      def upgrade(&progress)
+      def upgrade(&)
         was_login = installed? && login == "enabled"
-        install(force: true, login: was_login, &progress)
+        install(force: true, login: was_login, &)
       end
 
       # SMAppService status as the app reports it ("enabled",
@@ -212,7 +213,7 @@ module Samagotchi
         env = launch["env"].is_a?(Hash) ? launch["env"] : {}
         dump, = @runner.run([PBS, "-dump"])
         _, running = @runner.run(["pgrep", "-x", EXECUTABLE])
-        hotkey = (JSON.parse(File.read(hotkey_path)) rescue nil)
+        hotkey = JSON.parse(File.read(hotkey_path)) rescue nil
         result.merge(
           app_version: app_version,
           login: login,

data/lib/samagotchi/empty_answer_retry.rb

@@ -30,7 +30,7 @@ module Samagotchi
     # The request options of a retry generation: the turn's sampling, with
     # TEMPERATURE when it sets none (a configured nil keeps "don't send").
     def self.sampling(base)
-      base = base || {}
+      base ||= {}
       base.key?(:temperature) ? base : base.merge(temperature: TEMPERATURE)
     end
 

data/lib/samagotchi/engine.rb

@@ -47,6 +47,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 +105,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
@@ -325,6 +331,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 +413,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
@@ -557,8 +629,8 @@ module Samagotchi
 
     # Run the block with the event log held: no event is numbered or
     # delivered meanwhile, and events the block emits keep their order.
-    def synchronize_events(&block)
-      @session_observer.synchronize(&block)
+    def synchronize_events(&)
+      @session_observer.synchronize(&)
     end
 
     # Add a context note to the session's conversation, between turns: a
@@ -638,8 +710,8 @@ module Samagotchi
     # Start an anytime command on its own thread (D8), one #shutdown waits
     # for, so its command_ran is announced before the process leaves.
     # @return [Thread]
-    def spawn_anytime(&block)
-      thread = Thread.new(&block)
+    def spawn_anytime(&)
+      thread = Thread.new(&)
       @lifecycle_mutex.synchronize do
         @anytime_threads.select!(&:alive?)
         @anytime_threads << thread
@@ -656,9 +728,9 @@ module Samagotchi
 
     # Add a plugin's init task (Plugin::Api#init at commit); it starts with
     # #start_init_tasks!.
-    def add_init_task(bundle:, label:, plugin_label:, provides_tools:, quiet:, timeout:, failed: nil, &block)
+    def add_init_task(bundle:, label:, plugin_label:, provides_tools:, quiet:, timeout:, failed: nil, &)
       @plugin_tasks.add(bundle: bundle, label: label, plugin_label: plugin_label, provides_tools: provides_tools,
-                        quiet: quiet, timeout: timeout, failed: failed, &block)
+                        quiet: quiet, timeout: timeout, failed: failed, &)
     end
 
     # Start the init tasks not started yet, each on its own thread
@@ -836,8 +908,8 @@ module Samagotchi
     # @param name [Symbol] one of the hook names (see Hooks module)
     # @param block [Proc] receives an event hash (may mutate in place)
     # @return [void]
-    def register_hook(name, &block)
-      @hooks.register(name, &block)
+    def register_hook(name, &)
+      @hooks.register(name, &)
     end
 
     # Unregister a previously registered hook.
@@ -1369,9 +1441,7 @@ module Samagotchi
     end
 
     # @return [Session] current session (Engine owns create/resume)
-    def session
-      @session
-    end
+    attr_reader :session
 
     # The kernel's Tools::Peers, following the current session. cancelled?
     # is the running turn's cancel, for a tool that waits (delegate_result):
@@ -1424,9 +1494,7 @@ module Samagotchi
     end
 
     # @return [IdleRecap, nil] the idle recap detector, or nil when disabled
-    def recap
-      @recap
-    end
+    attr_reader :recap
 
     # Write the recap now, before the session is left (IdleRecap#write_now).
     # @return [String, nil] the recap written, nil when none was (recap off,
@@ -1887,6 +1955,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,
@@ -2128,6 +2198,7 @@ module Samagotchi
       config_path = Samagotchi::ConfigFile.global_path
       data = Samagotchi::ConfigFile.read_yaml(path: config_path)
       return Hooks::Loader.load(data, failures: @guardrail_failures) if data.is_a?(Hash)
+
       Hooks::Registry.new
     end
 
@@ -2150,11 +2221,15 @@ module Samagotchi
           Hooks::BundleLoader.load(bundle_name: bundle_name, hooks_dir: hooks_dir, metadata: data[:hooks], registry: @hooks,
                                    failures: @guardrail_failures, settings: settings[bundle_name.to_s] || {},
                                    requires_chi: data[:requires_chi])
-        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_load_failed", echo: "[samagotchi:hooks] bundle '#{bundle_name}' failed to load hooks: #{e.class}: #{e.message}", bundle: bundle_name, error: e.class.name)
         end
       end
-    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, "bundles_load_failed", echo: "[samagotchi:hooks] failed to load bundle hooks: #{e.class}: #{e.message}", error: e.class.name)
     end
 
@@ -2278,7 +2353,6 @@ module Samagotchi
     end
     private :bundle_settings
 
-
     # The session's current model as a recap target: its host's OpenAI API
     # (native llama.cpp hosts serve /v1/chat/completions too), key variable
     # and bare model name, as a turn resolves them.
@@ -2331,11 +2405,16 @@ module Samagotchi
         progress = nil
         case event[:type]
         when :generation_started
+          @generation_phase.started!
           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?
+        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.

data/lib/samagotchi/gem_update.rb

@@ -15,7 +15,8 @@ module Samagotchi
   # SAMAGOTCHI_UPDATE_GEM_FILE=<path to a .gem> (hidden, for smokes) makes that
   # file the newest version and installs it instead.
   class GemUpdate
-    Error = Class.new(StandardError)
+    class Error < StandardError
+    end
 
     LATEST_URL = URI("https://rubygems.org/api/v1/versions/samagotchi/latest.json")
     # Not SAMAGOTCHI_UPDATE_GEM: that is the env form of config update.gem.