samagotchi 0.12.0 → 0.14.0

data/lib/samagotchi/cli/parent_wait.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../session"
+require_relative "../reply_wait"
+require_relative "../parent_report"
+require_relative "exit"
+
+module Samagotchi
+  module CLI
+    # The parent-agent side shared by `chi send --wait` and `chi answer`:
+    # --format json's one object whatever the end, the session id resolved
+    # for it, and the wait for what comes next, reported the ParentReport
+    # way (Ctrl-C included). The including class (a CLI::Command) defines
+    # #parse (options, or an exit status) and #run_parsed(options), sets
+    # @stdout, @stderr and @state_dir, and may override the constants
+    # (specs stub them on the class).
+    module ParentWait
+      POLL_INTERVAL = ReplyWait::POLL_INTERVAL
+      # No live worker this long while waiting: it died before it could mark
+      # the session (a worker takes well under a second to start).
+      WORKER_GONE_AFTER = 5
+      FORMATS = %w[text json].freeze
+
+      # @return [Integer] the exit status
+      def run
+        options = parse
+        return options if options.is_a?(Integer)
+
+        @json = options[:format] == "json"
+        # With --format json stdout is one JSON object, whatever the end: a
+        # failure before the wait is reported from stderr's last line.
+        @stderr = ParentReport::LastLine.new(@stderr) if @json
+        status = run_parsed(options)
+        if @json && !@reported && status == 1
+          detail = @stderr.last.to_s.delete_prefix("#{command_name}: ")
+          @stdout.puts(ParentReport.error_line(detail, session_id: @session_id))
+          @stdout.flush
+        end
+        status
+      end
+
+      private
+
+      # The full id of +given+ (an id or a prefix), kept for the JSON
+      # error line; nil after the error line.
+      # @return [String, nil]
+      def resolve(given)
+        id = Session.resolve_id(given, state_dir: @state_dir)
+        Session.load(id, state_dir: @state_dir)
+        @session_id = id
+      rescue ArgumentError => e
+        error_line("#{command_name}: #{e.is_a?(Session::AmbiguousId) ? e.message : "no session #{given}"}")
+        nil
+      end
+
+      # Wait for the session's next reply past +cursor+ (ReplyWait) and
+      # report it. Ctrl-C leaves the turn running (130).
+      # @param owner_grace [Numeric, nil] seconds with no live worker before
+      #   it counts as gone; nil waits for whatever wakes one
+      # @return [Integer] the exit status
+      def wait_for_reply(id, cursor:, baseline:, timeout:, owner_grace: self.class::WORKER_GONE_AFTER)
+        result = ReplyWait.call(id, state_dir: @state_dir, cursor: cursor, timeout: timeout, baseline: baseline,
+                                    owner_grace: owner_grace, poll_interval: self.class::POLL_INTERVAL)
+        result.text = result.text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
+        @reported = true
+        ParentReport.report(result, session_id: id, stdout: @stdout, stderr: @stderr, command: command_name,
+                                    json: @json, timeout: timeout)
+      rescue Interrupt
+        if @json
+          @stdout.puts(ParentReport.json_line(ReplyWait::Result.new(status: :canceled), session_id: id))
+          @stdout.flush
+          @reported = true
+        end
+        error_line("#{command_name}: still running: chi --attach #{id}")
+        Exit::INTERRUPTED
+      rescue ArgumentError
+        error_line("#{command_name}: the session is gone (deleted while waiting)")
+        Exit::FAILED
+      end
+    end
+  end
+end

data/lib/samagotchi/config.rb

@@ -104,10 +104,14 @@ module Samagotchi
       Entry.new(key: "image.max_bytes",          yaml_path: %w[image max_bytes],          type: :integer, default: 3_750_000,       expose: %i[env config]),
       Entry.new(key: "image.max_per_request",    yaml_path: %w[image max_per_request],    type: :integer, default: 20,              expose: %i[env config]),
 
-      Entry.new(key: "guardrails.enabled",       yaml_path: %w[guardrails enabled],       type: :bool,   default: true,             expose: %i[env config]),
+      # The guardrails settings are config.yml only: a parent agent must not switch a child's guardrails off from its
+      # own environment (SAMAGOTCHI_GUARDRAILS_ENABLED=false). SessionManager.spawn_options unsets them for a worker too.
+      Entry.new(key: "guardrails.enabled",       yaml_path: %w[guardrails enabled],       type: :bool,   default: true,             expose: %i[config]),
       # Which models get the rules with `models: small` (Guardrails::ModelSize): auto (32B or less by the name's size, an MoE's
       # active size counting), globs on the bare model name or its key, "|"-separated (a YAML list works too), or "" ([]) for none.
-      Entry.new(key: "guardrails.small_models",  yaml_path: %w[guardrails small_models],  type: :string, default: "auto",           expose: %i[env config]),
+      Entry.new(key: "guardrails.small_models",  yaml_path: %w[guardrails small_models],  type: :string, default: "auto",           expose: %i[config]),
+      # What `chi answer` lets a parent agent allow on an approval: off (deny only) or once ("Allow once", never a wider scope).
+      Entry.new(key: "guardrails.parent_approvals", yaml_path: %w[guardrails parent_approvals], type: :enum, default: "off", expose: %i[config], enum_values: %w[off once]),
 
       Entry.new(key: "log.file",                 yaml_path: %w[log file],                 type: :string, default: nil,              expose: %i[env config cli]),
       Entry.new(key: "log.disable",              yaml_path: %w[log disable],              type: :bool,   default: false,            expose: %i[env config cli]),
@@ -156,6 +160,8 @@ module Samagotchi
       Entry.new(key: "execute.truncate_at_bytes",       yaml_path: %w[execute truncate_at_bytes],       type: :integer, default: 65_536, expose: %i[env config cli]),
       Entry.new(key: "execute.preview_bytes",           yaml_path: %w[execute preview_bytes],           type: :integer, default: 12_288, expose: %i[env config cli]),
       Entry.new(key: "execute.telemetry_threshold_pct", yaml_path: %w[execute telemetry_threshold_pct], type: :integer, default: 80,     expose: %i[env config cli]),
+      # Seconds one execute command may run before it is stopped (Tools::Execute::TIMEOUT_SEC).
+      Entry.new(key: "execute.timeout_sec",             yaml_path: %w[execute timeout_sec],             type: :integer, default: 30,     expose: %i[env config cli]),
 
       Entry.new(key: "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]),
@@ -181,8 +187,9 @@ module Samagotchi
     # Maps of named entries and the keys an entry may hold
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
-      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled].freeze,
-      "models" => %w[profile vision sampling thinking].freeze
+      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled
+                    remote window_tokens].freeze,
+      "models" => %w[profile vision sampling thinking window_tokens].freeze
     }.freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
     SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze }.freeze
@@ -597,7 +604,23 @@ module Samagotchi
 
     # A `vision:` setting (hosts entry or models: entry): true, false, or nil
     # when unset. Anything else warns once and counts as unset.
-    def vision_flag(value, where)
+    def vision_flag(value, where) = bool_flag(value, where, "vision")
+
+    # A `window_tokens:` setting (hosts entry or models: entry): a positive
+    # integer, nil when unset; anything else warns once and counts as unset.
+    def window_tokens(value, where)
+      return nil if value.nil?
+
+      tokens = Integer(value.to_s.strip, exception: false)
+      return tokens if tokens&.positive?
+
+      warn_once "Warning: #{where}: window_tokens must be a positive number of tokens; ignored"
+      nil
+    end
+
+    # A true/false setting +key+ of a map entry, nil when unset; anything
+    # 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
 
@@ -605,7 +628,7 @@ module Samagotchi
       return true if text == "true"
       return false if text == "false"
 
-      warn_once "Warning: #{where}: vision must be true or false; ignored"
+      warn_once "Warning: #{where}: #{key} must be true or false; ignored"
       nil
     end
 
@@ -695,18 +718,7 @@ module Samagotchi
 
     def hosts_config(env: ENV, path: global_path(env: env))
       data = read_yaml(env: env, path: path)
-      raw_hosts = data[HOSTS_KEY] if data.is_a?(Hash)
-
-      # ENV override: SAMAGOTCHI_HOSTS_JSON (used to propagate to workers)
-      env_json = env["SAMAGOTCHI_HOSTS_JSON"].to_s.strip
-      unless env_json.empty?
-        begin
-          parsed_env = JSON.parse(env_json)
-          raw_hosts = parsed_env if parsed_env.is_a?(Hash)
-        rescue StandardError
-          nil
-        end
-      end
+      raw_hosts = hosts_source(data, env)
 
       normalized = {}
       if raw_hosts.is_a?(Hash)
@@ -726,16 +738,18 @@ module Samagotchi
           port = raw_cfg["port"] || raw_cfg[:port]
           transport = raw_cfg["transport"] || raw_cfg[:transport]
           api = raw_cfg["api"] || raw_cfg[:api]
-          enabled = raw_cfg.key?("enabled") ? raw_cfg["enabled"] : (raw_cfg.key?(:enabled) ? raw_cfg[:enabled] : true)
-          if enabled == false || enabled.to_s.strip.downcase == "false"
-            next
-          end
+          next if host_disabled?(raw_cfg)
+
           url = (raw_cfg["url"] || raw_cfg[:url]).to_s.strip
           api_key_env = (raw_cfg["api_key_env"] || raw_cfg[:api_key_env]).to_s.strip
           # Kept as written; ModelProfile.resolve warns about an unknown one.
           profile = (raw_cfg["profile"] || raw_cfg[:profile]).to_s.strip.downcase
           first_token_timeout = raw_cfg.key?("first_token_timeout") ? raw_cfg["first_token_timeout"] : raw_cfg[:first_token_timeout]
           vision = ConfigFile.vision_flag(raw_cfg.key?("vision") ? raw_cfg["vision"] : raw_cfg[:vision], "hosts entry '#{name}'")
+          remote = ConfigFile.bool_flag(raw_cfg.key?("remote") ? raw_cfg["remote"] : raw_cfg[:remote], "hosts entry '#{name}'",
+                                        "remote")
+          window = ConfigFile.window_tokens(raw_cfg.key?("window_tokens") ? raw_cfg["window_tokens"] : raw_cfg[:window_tokens],
+                                            "hosts entry '#{name}'")
           sampling = ConfigFile.sampling_map(raw_cfg.key?("sampling") ? raw_cfg["sampling"] : raw_cfg[:sampling], "hosts entry '#{name}'")
           thinking = Thinking.level(raw_cfg.key?("thinking") ? raw_cfg["thinking"] : raw_cfg[:thinking], "hosts entry '#{name}'")
           unless first_token_timeout.nil? || (first_token_timeout.is_a?(Numeric) && !first_token_timeout.negative?)
@@ -801,7 +815,8 @@ module Samagotchi
                                   api: api_val&.to_sym, original_name: name, scheme: scheme,
                                   url: url.empty? ? nil : url, api_key_env: api_key_env.empty? ? nil : api_key_env,
                                   profile: profile.empty? ? nil : profile, first_token_timeout: first_token_timeout,
-                                  vision: vision, sampling: sampling, thinking: thinking }
+                                  vision: vision, sampling: sampling, thinking: thinking, remote: remote,
+                                  window_tokens: window }
         end
       end
 
@@ -822,6 +837,42 @@ module Samagotchi
       {}
     end
 
+    # The names (lowercased) of the hosts entries with enabled: false, which
+    # hosts_config leaves out. Read from the same source: config.yml's
+    # hosts:, or SAMAGOTCHI_HOSTS_JSON in a worker.
+    # @return [Array<String>]
+    def disabled_host_names(env: ENV, path: global_path(env: env))
+      raw = hosts_source(read_yaml(env: env, path: path), env)
+      return [] unless raw.is_a?(Hash)
+
+      raw.filter_map { |name, cfg| name.to_s.strip.downcase if cfg.is_a?(Hash) && host_disabled?(cfg) }
+    rescue StandardError
+      []
+    end
+
+    # config.yml's hosts: as written, or the SAMAGOTCHI_HOSTS_JSON override
+    # a worker inherits from its parent.
+    def hosts_source(data, env)
+      raw = data[HOSTS_KEY] if data.is_a?(Hash)
+      env_json = env["SAMAGOTCHI_HOSTS_JSON"].to_s.strip
+      return raw if env_json.empty?
+
+      parsed = begin
+        JSON.parse(env_json)
+      rescue StandardError
+        nil
+      end
+      parsed.is_a?(Hash) ? parsed : raw
+    end
+    private_class_method :hosts_source
+
+    # 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 == false || enabled.to_s.strip.downcase == "false"
+    end
+    private_class_method :host_disabled?
+
     # Resolve the `recap:` section through the Config registry so scalar
     # recap settings share the single precedence path (CLI > ENV > file >
     # default). Returns false when explicitly disabled (file `recap: false`
@@ -906,8 +957,12 @@ module Samagotchi
         location = v[:url] ? { "url" => v[:url] } : { "host" => v[:host], "port" => v[:port] }
         location.merge("transport" => v[:transport]&.to_s, "api" => v[:api]&.to_s, "api_key_env" => v[:api_key_env],
                        "profile" => v[:profile], "first_token_timeout" => v[:first_token_timeout],
-                       "vision" => v[:vision], "sampling" => v[:sampling], "thinking" => v[:thinking]&.to_s).compact
+                       "vision" => v[:vision], "sampling" => v[:sampling], "thinking" => v[:thinking]&.to_s,
+                       "remote" => v[:remote], "window_tokens" => v[:window_tokens]).compact
       end
+      # Disabled hosts travel as just that, so a worker refuses "box:x"
+      # the way its parent does instead of sending it to the default host.
+      disabled_host_names(env: env, path: path).grep(HOST_NAME_RE).each { |name| simple[name] ||= { "enabled" => false } }
       JSON.generate(simple)
     rescue StandardError
       nil
@@ -991,6 +1046,8 @@ module Samagotchi
         result[key][:sampling] = sampling if sampling
         thinking = Thinking.level(v.key?("thinking") ? v["thinking"] : v[:thinking], "models: #{key}")
         result[key][:thinking] = thinking if thinking
+        window = window_tokens(v.key?("window_tokens") ? v["window_tokens"] : v[:window_tokens], "models: #{key}")
+        result[key][:window_tokens] = window if window
       end
     rescue StandardError
       {}

data/lib/samagotchi/context_window.rb

@@ -9,11 +9,16 @@ module Samagotchi
   #   1. the running server (Client#context_window, e.g. llama.cpp's n_ctx)
   #   2. the host's model list (a chat adapter's #context_window, e.g. a
   #      provider's context_length)
-  #   3. context.window_tokens (CLI, SAMAGOTCHI_CONTEXT_WINDOW_TOKENS or the
-  #      config file); it only fills in when the server reports nothing
-  #   4. DEFAULT_TOKENS
+  #   3. models.<key>.window_tokens, else hosts.<name>.window_tokens
+  #      (#setting: the most specific wins)
+  #   4. context.window_tokens (CLI, SAMAGOTCHI_CONTEXT_WINDOW_TOKENS or the
+  #      config file)
+  #   5. DEFAULT_TOKENS
+  # Settings (3 and 4) only fill in when the server and its list report
+  # nothing.
   #
-  # Sources: :server, :model_list, :config (CLI or file), :env, :default.
+  # Sources: :server, :model_list, :model_setting, :host_setting, :config
+  # (CLI or file), :env, :default.
   module ContextWindow
     DEFAULT_TOKENS = 256_000
 
@@ -22,7 +27,8 @@ module Samagotchi
     module_function
 
     # @param adapter [#context_window, nil] the host's chat adapter
-    def resolve(client: nil, model: nil, adapter: nil)
+    # @param setting [Resolved, nil] the model's or host's window (#setting)
+    def resolve(client: nil, model: nil, adapter: nil, setting: nil)
       server_tokens = client.context_window(model: model) if client.respond_to?(:context_window)
       if positive_integer?(server_tokens)
         @last_server = Resolved.new(tokens: server_tokens, source: :server)
@@ -34,10 +40,29 @@ module Samagotchi
         @last_server = Resolved.new(tokens: listed, source: :model_list)
         return @last_server
       end
+      return @last_server = setting if setting
 
       configured
     end
 
+    # The window config.yml gives this model or its host:
+    # models.<key>.window_tokens (by the model's lookup names, as sampling
+    # and vision look a model up), else hosts.<name>.window_tokens.
+    # @param target [HostRegistry::ModelTarget]
+    # @param names [Array<String>] HostRegistry#lookup_names
+    # @param models [Hash, nil] ConfigFile.model_settings (specs)
+    # @return [Resolved, nil]
+    def setting(target, names:, models: nil)
+      models ||= ConfigFile.model_settings
+      _key, tokens = ConfigFile.model_setting(names, :window_tokens, models: models)
+      return Resolved.new(tokens: tokens, source: :model_setting) if positive_integer?(tokens)
+
+      tokens = target&.entry&.window_tokens
+      positive_integer?(tokens) ? Resolved.new(tokens: tokens, source: :host_setting) : nil
+    rescue StandardError
+      nil
+    end
+
     # The window without asking a server: config, env, then the default.
     # `env` resolves against that env's config file instead of the live
     # process config (for `chi self`).

data/lib/samagotchi/desktop_command.rb

@@ -6,7 +6,8 @@ require_relative "desktop"
 
 module Samagotchi
   # `chi desktop install|upgrade|uninstall|status`: the native helper that
-  # sends selected text to live sessions as a context note (macOS for now).
+  # sends selected text (or images) to sessions, live, stopped or new, as a
+  # message or a context note (macOS for now).
   class DesktopCommand
     include CLI::Command
 
@@ -15,8 +16,9 @@ module Samagotchi
         install [--force] [--login]
                            build "Chi Helper" into ~/Applications (needs the Command Line Tools)
                            and start it: Services > "Send to chi", or ⌃⌥⌘N with the clipboard,
-                           sends text to a live session as a context note. --login: start it
-                           at login too (else it runs until you log out)
+                           sends text or images to a session (live, stopped or new) as a
+                           message (⏎) or a context note (⌘⏎). --login: start it at login
+                           too (else it runs until you log out)
         upgrade            rebuild it for this chi and restart it (chi update does this only
                            when its sources changed)
         uninstall          remove it, its settings and its launch file

data/lib/samagotchi/engine.rb

@@ -223,8 +223,6 @@ module Samagotchi
       # memory_read guard reads the same list for every turn.
       @muted_memory_names = MutedMemories.normalize_list(muted_memories)
       @kernel.muted_memory_names = @muted_memory_names
-      # Keep kernel client in sync with active host via setter
-      @kernel_client_synced = false
       # ask_user_question blocks on the Engine's question flow (TUI/Web answer it).
       @kernel.question_handler = proc { |payload| request_question(payload) }
       # Every tool call asks this gate first. The kernel is never rebuilt, so
@@ -967,10 +965,6 @@ module Samagotchi
       @prompt_builder.preloaded_memory_names
     end
 
-    def memory_muted?(name)
-      MutedMemories.muted?(name, @muted_memory_names)
-    end
-
     # ── Guardrails ─────────────────────────────────────────────────────────────
 
     # Who can answer an approval: :repl, :worker or :non_interactive (the
@@ -1245,8 +1239,8 @@ module Samagotchi
 
     # Answer the pending question (called from UI thread; QuestionDesk#answer).
     # @return [Hash] normalized answer
-    def answer_question(id:, selected:, freeform: nil)
-      @question_desk.answer(id: id, selected: selected, freeform: freeform)
+    def answer_question(id:, selected:, freeform: nil, client_id: nil)
+      @question_desk.answer(id: id, selected: selected, freeform: freeform, client_id: client_id)
     end
 
     def set_question_sync_handler(&block)
@@ -1412,7 +1406,7 @@ module Samagotchi
     # the prompt is kept in the session and :turn_canceled is emitted, then the
     # Interrupt is re-raised so the caller still decides whether to exit. One
     # after the turn's end event (in its after_turn/session_end hooks) is
-    # only re-raised: the turn already ended. Any
+    # only re-raised: the turn already ended; so is any error there. Any
     # other error (e.g. an LLM::ProviderError) emits :turn_failed and
     # re-raises; a provider error adds error_kind:, retryable:, host: and a
     # one-line summary:.
@@ -1424,7 +1418,8 @@ module Samagotchi
         # A Stop cuts the /props probes this thread makes for the turn
         # (window, served model, vision) instead of waiting their timeout.
         probe_cancel_before = Client.swap_probe_cancel(turn.controller)
-        prepare_turn(turn, continue ? [] : images)
+        return stopped_before_model(turn) unless prepare_turn(turn, continue ? [] : images)
+
         result = generate(turn, max_iterations: max_iterations, max_tool_output_chars: max_tool_output_chars,
                                 pending_input: pending_input)
         publish_used_memories(session, on_event)
@@ -1441,6 +1436,13 @@ module Samagotchi
         end
         raise
       rescue StandardError => e
+        # After the end event (post-turn work) likewise: logged and
+        # re-raised, no turn_failed over the turn that ended.
+        if turn.ended
+          Log.warn(:turn, "post_turn_error", error: "#{e.class}: #{e.message}")
+          raise
+        end
+
         # Keep what the turn got to (the prompt plus the loop's completed
         # tool iterations) like a cancel does, and save it: a worker exits
         # after a failed turn. The REPL still rolls back to its checkpoint.
@@ -1482,7 +1484,9 @@ module Samagotchi
 
     # Everything before the model is asked: :turn_started, the kernel's
     # per-turn settings, the plugins' setup, the session_start/before_turn
-    # hooks, then the messages to send (#turn_messages).
+    # hooks, then the messages to send (#turn_messages). False when a Stop
+    # came before the hooks (the turn ends canceled there; before the
+    # load-failure warnings when it came during the probes), else true.
     def prepare_turn(turn, images)
       session = turn.session
       image_refs, image_error = turn_image_refs(session, images)
@@ -1506,6 +1510,10 @@ module Samagotchi
       # Before anything of the turn is kept or a reminder is used up.
       turn.settings = turn_settings(session)
       refuse_images!(turn.settings.vision) unless image_refs.empty?
+      # A Stop during the probes: the turn ends before the load-failure
+      # warnings, which show once, so the next turn still shows them.
+      return false if turn.controller.cancelled?
+
       announce_guardrail_failures(turn.on_event)
       # Plugins' slow setup that brings tools (an MCP server's first
       # start): the turn waits for it here, before the system prompt
@@ -1515,6 +1523,9 @@ module Samagotchi
       await_init_tasks(turn.controller, turn.on_event)
       # Plugins' tool sets that changed since the last turn.
       apply_staged_tools!
+      # A Stop during the wait above: the turn ends here,
+      # before the hooks run or a reminder is used up.
+      return false if turn.controller.cancelled?
 
       # Fire :session_start on the very first turn
       if @first_turn
@@ -1528,9 +1539,22 @@ module Samagotchi
                                   messages: hook_messages(session.messages) })
 
       turn_messages(turn, image_refs)
+      true
     end
     private :prepare_turn
 
+    # A turn stopped before the model was asked (#prepare_turn returned
+    # false): canceled with nothing kept, like a Ctrl-C there; the result
+    # has no conversation, so a UI's checkpoint stands.
+    def stopped_before_model(turn)
+      reason = turn.controller.reason
+      end_turn(turn, "canceled") do |seconds|
+        [nil, { type: :turn_canceled, cancellation_reason: reason, duration_ms: (seconds * 1000).round }]
+      end
+      LLM::ModelResult.new(text: "", canceled: true, cancellation_reason: reason)
+    end
+    private :stopped_before_model
+
     # The turn's settings for the kernel (LLM::TurnSettings): vision,
     # sampling and thinking, the thinking resolved before the hooks run.
     # The model name is added in #generate, after the hooks that may switch
@@ -1541,7 +1565,8 @@ module Samagotchi
       thinking_target = @host_registry.resolve(@effective_model_name)
       @turn_thinking = [thinking_level(thinking_target), thinking_target]
       announce_thinking_level(*@turn_thinking)
-      LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first, model_name: nil)
+      LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first, model_name: nil,
+                            window_setting: nil)
     end
     private :turn_settings
 
@@ -1586,7 +1611,7 @@ module Samagotchi
       # The turn's settings, set once here. The chat loop dispatches tools
       # through the kernel without its #run: tag those dumps with this
       # turn's model, not the last native one.
-      @kernel.turn_settings = turn.settings.with(model_name: bare_for_backend)
+      @kernel.turn_settings = turn.settings.with(model_name: bare_for_backend, window_setting: turn_window_setting)
 
       backend.complete(
         messages: turn.messages,
@@ -1640,7 +1665,8 @@ module Samagotchi
         end
       end
 
-      # Fire :after_turn hook (runs even on cancel/success), with a read-only
+      # Fire :after_turn hook (an answer or a Stop; an Interrupt or a failure
+      # ends the turn in #run_turn without it), with a read-only
       # copy of the conversation the turn stored, and event[:present] for
       # a display version of the answer (AnswerDisplay).
       session = turn.session
@@ -1651,7 +1677,7 @@ module Samagotchi
       @hooks.fire(:after_turn, after_turn)
       store_answer_display(session, display, pending: display_pending)
 
-      # Fire :session_end after every turn (turn-level lifecycle)
+      # Fire :session_end after the turn (turn-level lifecycle), as :after_turn
       @hooks.fire(:session_end, { type: :session_end, session_id: session.id })
     end
     private :complete_turn
@@ -1973,7 +1999,8 @@ module Samagotchi
         end
         begin
           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] || {})
+                                   failures: @guardrail_failures, settings: settings[bundle_name.to_s] || {},
+                                   requires_chi: data[:requires_chi])
         rescue Exception => e
           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
@@ -2218,7 +2245,17 @@ module Samagotchi
         adapter = @host_registry.adapter_for(target.entry)
         client = nil if adapter.remote?
       end
-      ContextWindow.resolve(client: client, model: target.bare_model, adapter: adapter)
+      ContextWindow.resolve(client: client, model: target.bare_model, adapter: adapter,
+                            setting: ContextWindow.setting(target, names: model_lookup_names(target)))
+    rescue StandardError
+      nil
+    end
+
+    # The effective model's models:/hosts: window_tokens, read per turn
+    # (after the hooks that may switch the model).
+    def turn_window_setting
+      target = @host_registry.resolve(@effective_model_name)
+      ContextWindow.setting(target, names: model_lookup_names(target))
     rescue StandardError
       nil
     end