samagotchi 0.21.0 → 0.23.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]),
@@ -186,7 +185,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 +227,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 +268,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 +297,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 +325,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 +345,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 +364,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 +408,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 +430,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 +558,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 +594,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 +606,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 +644,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 +666,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 +675,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 +702,7 @@ module Samagotchi
     def clear_yaml_cache!(path = nil)
       cache = @yaml_cache
       return if cache.nil?
+
       if path
         cache.delete(path)
       else
@@ -734,6 +750,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 +812,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 +852,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 +894,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 +980,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 +1012,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 +1048,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
@@ -41,6 +42,9 @@ module Samagotchi
       # A question was posted since the last close (it may have been
       # answered or superseded meanwhile).
       @asked = false
+      # The text a Continue answer came with ({text:, source:}): it steers
+      # the continue turn (#run_continue_turn).
+      @continue_steer = nil
     end
 
     attr_writer :queue_command
@@ -52,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
@@ -62,6 +66,7 @@ module Samagotchi
     def drop(origin)
       return unless awaiting?
 
+      @continue_steer = nil
       close("dropped")
       @engine.synchronize_events do
         @turn_flow.drop_offer!
@@ -95,6 +100,10 @@ module Samagotchi
       close(resolved ? "answered" : "dropped") unless awaiting?
       return unless resolved
 
+      # Answered without a turn (a typed /continue no that got there before
+      # the answer's /continue yes): the answer's text steers nothing.
+      @continue_steer = nil unless result.resume
+
       # 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
@@ -103,18 +112,32 @@ 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.
+    # 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")
-      @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])
+      steer = @continue_steer
+      @continue_steer = nil
+      begin
+        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
+            announce_offer(offer)
+          else
+            after_turn(result, continue: true, no_interrupt: offer[:no_interrupt])
+          end
         end
+      ensure
+        @engine.drop_carried_steers if steer
       end
     end
 
@@ -129,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
@@ -164,9 +187,18 @@ module Samagotchi
     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>.
+    # Continue → yes, and a text with it steers the continue turn (from the
+    # parent agent when the answer says so); Stop → no; a text (with Stop,
+    # or alone) → no, <text>.
     def answered(answer, client_id:)
+      # The /continue line takes the text on one line; the steer keeps its
+      # line breaks.
       text = answer[:freeform].to_s.gsub(/\s+/, " ").strip
+      @continue_steer = nil
+      if Array(answer[:selected]).include?(CONTINUE) && !text.empty?
+        @continue_steer = { text: answer[:freeform].to_s.strip,
+                            source: answer[:by] == "parent_agent" ? "parent_agent" : "user" }
+      end
       line = if Array(answer[:selected]).include?(CONTINUE) then "/continue yes"
              elsif text.empty? then "/continue no"
              else "/continue no, #{text}"

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

@@ -325,6 +325,21 @@ module Samagotchi
       @turn_state.steer(text, source: source)
     end
 
+    # 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
+    # #drop_carried_steers drops it.
+    # @return [Boolean] whether it was queued (false: blank)
+    def steer_next_turn(text, source:)
+      @turn_state.steer_next_turn(text, source: source)
+    end
+
+    # Drop the #steer_next_turn steers no turn began with (the continue turn
+    # failed before it began), logged; a no-op once a turn took them.
+    def drop_carried_steers
+      log_dropped_steers(@turn_state.drop_carried_steers, "not_begun")
+    end
+
     # The drain a turn's loop gets: the caller's lines (a UI's steering; nil
     # 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
@@ -542,8 +557,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
@@ -623,8 +638,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
@@ -641,9 +656,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
@@ -821,8 +836,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.
@@ -1089,7 +1104,8 @@ module Samagotchi
     # @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)
+    # @param event [Hash] the turn's end event (#stop_facts)
+    def record_last_turn(session, outcome, seconds, origin, event, 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"
@@ -1098,9 +1114,23 @@ module Samagotchi
       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
+      session.last_turn.merge!(stop_facts(event))
     end
     private :record_last_turn
 
+    # Why a turn stopped, from its end event, for a parent agent's wait
+    # (ReplyWait): a provider error's kind and whether a retry may help, a
+    # cancel's reason and the hook that stopped it. Only what is known.
+    def stop_facts(event)
+      case event&.dig(:type)
+      when :turn_failed then { "error_kind" => event[:error_kind]&.to_s, "retryable" => event[:retryable] }.compact
+      when :turn_canceled
+        { "cancel_reason" => event[:cancellation_reason]&.to_s, "stopped_by" => event[:cancelled_by]&.to_s }.compact
+      else {}
+      end
+    end
+    private :stop_facts
+
     # How every turn ends (completed, canceled, failed): the session gets
     # what the turn kept, goes idle and records the ending, and the end
     # event is announced, as one step of the event log (a snapshot taken
@@ -1118,7 +1148,7 @@ module Samagotchi
         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, limit: exhausted ? turn.limit : nil)
+        record_last_turn(turn.session, outcome, seconds, turn.origin, event, limit: exhausted ? turn.limit : nil)
         emit_event(turn.on_event, turn.tag(event))
       end
       turn.ended = true
@@ -1339,9 +1369,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):
@@ -1394,9 +1422,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,
@@ -2098,6 +2124,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
 
@@ -2120,11 +2147,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
 
@@ -2248,7 +2279,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.

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.

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