samagotchi 0.13.0 → 0.15.0

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

@@ -1,11 +1,11 @@
 ---
 name: mcp
-version: 0.3.2
+version: 0.4.0
 scope: system
 description: "Tools from MCP servers (stdio): each server in config.yml bundles: mcp: servers: runs for the session, its tools are mcp_<server>_<tool>; /mcp lists them"
 trust_level: reviewed
 files: {}
 plugin:
   file: plugin.rb
-  sha256: sha256:61b195a5621ddf57ba69a505aff06d620d6459e836d736205343a251b0fecb71
+  sha256: sha256:009dbb3b754958a6d9edb1e3b828f486aa0ddd09ff5b548f0c576abbfea18807
 requires_chi: ">= 0.8.0"

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -13,15 +13,18 @@
 #           cwd: ~/scratch      # default: where chi runs
 #           tools: [echo, add]  # optional: only these (globs work)
 #           timeout: 120        # optional: this server's per-call timeout
-#           attach_image_paths: true  # default: a result that is only the path of an
-#                                     # image in the temp dir or cwd attaches it
+#           attach_image_paths: true  # default: an image path in the text, in the
+#                                     # temp dir or cwd, attaches it
 #
 # Image blocks in a result go to the model as images (text: "[image 1:
-# image/png, attached]"); so does a text block that is only the absolute
-# path of an image file under the system temp dir or the server's cwd
-# (chrome-devtools-mcp --slim answers a screenshot that way).
+# image/png, attached]"); so does an image file named in a text block,
+# under the system temp dir or the server's cwd: the block is only its
+# absolute path (chrome-devtools-mcp --slim answers a screenshot that way),
+# or it says one ending in an image extension ("Saved it to /tmp/a.png.").
 # A server that doesn't start, answer or list its tools is skipped with a
-# notice; the rest of chi works. /mcp lists the servers and their tools.
+# notice; the rest of chi works. One that exits mid-session starts again on
+# its next call, at most MAX_RESTARTS times a session. /mcp lists the
+# servers and their tools.
 require "digest"
 require "json"
 require "open3"
@@ -38,6 +41,8 @@ class Plugin
   NAME_CHARS = 48
   # A cached tool list older than this is refreshed in the background.
   CACHE_TTL = 24 * 60 * 60
+  # Restarts of a server that exited, per session.
+  MAX_RESTARTS = 3
   IMAGE_EXT = { "image/png" => "png", "image/jpeg" => "jpg", "image/gif" => "gif", "image/webp" => "webp" }.freeze
 
   # A JSON-RPC client for one MCP server over stdio: newline-delimited JSON
@@ -60,9 +65,13 @@ class Plugin
     # @param log [#call] (event, fields) for stderr lines and protocol noise
     # @param on_exit [#call, nil] called once, with the reason, when the
     #   process ends while the client is open
-    def initialize(command, env: {}, cwd: Dir.pwd, log: ->(*) {}, on_exit: nil)
+    # @param on_notification [#call, nil] (method, params) for each
+    #   notification from the server, on the reader thread: it must not
+    #   wait for an answer there
+    def initialize(command, env: {}, cwd: Dir.pwd, log: ->(*) {}, on_exit: nil, on_notification: nil)
       @log = log
       @on_exit = on_exit
+      @on_notification = on_notification
       @mutex = Mutex.new
       @write_mutex = Mutex.new
       @pending = {}
@@ -179,8 +188,11 @@ class Plugin
     def dispatch(message)
       if message.key?("method")
         # A request from the server (ping, roots/list, …): ping is answered,
-        # the rest aren't supported. A notification is logged.
-        return @log.call("server_notification", method: message["method"]) unless message.key?("id")
+        # the rest aren't supported. A notification is logged and handed on.
+        unless message.key?("id")
+          @log.call("server_notification", method: message["method"])
+          return @on_notification&.call(message["method"], message["params"])
+        end
 
         answer = if message["method"] == "ping"
                    { jsonrpc: "2.0", id: message["id"], result: {} }
@@ -227,8 +239,10 @@ class Plugin
   # One configured server: its service, state and tools. +listed+ is its
   # tools/list as the server answers it (what the cache keeps), +tools+
   # the ones chi offers (the tools: filter applied, each with chi_name).
+  # +client+ is the running process's (a restart replaces it; the
+  # service's stop closes the current one), +restarts+ how many it had.
   Server = Struct.new(:name, :config, :service, :state, :error, :tools, :listed, :timeout, :cwd, :command, :env,
-                      :digest, :cached_at, keyword_init: true)
+                      :digest, :cached_at, :relist, :relisting, :client, :restarts, keyword_init: true)
 
   def initialize(settings = {})
     @settings = settings
@@ -236,6 +250,8 @@ class Plugin
     @startup_timeout = positive(settings["startup_timeout"]) || STARTUP_TIMEOUT
     @servers = []
     @publish = Mutex.new
+    @relist = Mutex.new
+    @restart = Mutex.new
     # The tools left out so far (a name clash): said once, not at each
     # publish.
     @left_out = []
@@ -255,7 +271,8 @@ class Plugin
     configs = @settings["servers"]
     configs = {} unless configs.is_a?(Hash)
     @servers = configs.map do |name, config|
-      server = Server.new(name: name.to_s, config: config.is_a?(Hash) ? config : {}, state: :starting, tools: [])
+      server = Server.new(name: name.to_s, config: config.is_a?(Hash) ? config : {}, state: :starting, tools: [],
+                          restarts: 0)
       server.timeout = positive(server.config["timeout"]) || @timeout
       resolve(server, ctx)
       server.service = chi.service(name) { |svc| start(server, svc, ctx) }
@@ -306,16 +323,29 @@ class Plugin
     server.digest = Digest::SHA256.hexdigest(JSON.generate([server.command, server.env.sort, server.cwd]))
   end
 
-  # The service's start: spawn, initialize, list the tools (cancelled with
-  # the turn that waits for it), then cache the list.
+  # The service's start: spawn (#spawn). Its stop closes the server's
+  # current process, a restarted one too.
   def start(server, svc, ctx)
     raise Client::Error, "no command (bundles: mcp: servers: #{server.name}: command: [...])" if server.command.empty?
 
+    svc.on_stop { server.client&.close }
+    spawn(server, ctx)
+  end
+
+  # Spawn the server's process (it is server.client from then on),
+  # initialize, list the tools (cancelled with the turn that waits for
+  # it), then cache the list.
+  # @return [Client]
+  def spawn(server, ctx)
     cancelled = -> { ctx.cancelled? }
-    client = Client.new(server.command, env: server.env, cwd: server.cwd,
-                                        log: ->(event, **fields) { ctx.log.debug("mcp_#{event}", server: server.name, **fields) },
-                                        on_exit: ->(reason) { exited(server, reason, ctx) })
-    svc.on_stop { client.close }
+    client = server.client = Client.new(
+      server.command, env: server.env, cwd: server.cwd,
+                      log: ->(event, **fields) { ctx.log.debug("mcp_#{event}", server: server.name, **fields) },
+                      on_exit: ->(reason) { exited(server, reason, ctx) },
+                      on_notification: lambda { |method, _params|
+                        tools_changed(server, ctx) if method == "notifications/tools/list_changed"
+                      }
+    )
     client.request("initialize", { protocolVersion: PROTOCOL_VERSION, capabilities: {},
                                    clientInfo: { name: "chi", version: Samagotchi::VERSION } },
                    timeout: @startup_timeout, cancelled: cancelled)
@@ -380,6 +410,46 @@ class Plugin
     nil
   end
 
+  # notifications/tools/list_changed from a running server: list its tools
+  # again (on a thread of its own: the answer comes on the reader thread
+  # that told us), save them and replace the tools for the next turn.
+  # Notices that come together list once more after the one running.
+  def tools_changed(server, ctx)
+    @relist.synchronize do
+      server.relist = true
+      return if server.relisting
+
+      server.relisting = true
+    end
+    Thread.new do
+      relist(server, ctx) while relist_pending?(server)
+    end
+  end
+
+  # Takes the server's pending relist: true once per notice; false (and
+  # the relisting thread ends) when none is left.
+  def relist_pending?(server)
+    @relist.synchronize do
+      pending = server.relist
+      server.relist = false
+      server.relisting = false unless pending
+      pending
+    end
+  end
+
+  def relist(server, ctx)
+    server.service.value # raises once stopped
+    listed = list_tools(server.client, nil)
+    return if listed == server.listed
+
+    server.listed = listed
+    save_cache(server, ctx)
+    ctx.log.info("mcp_tools_changed", server: server.name, tools: listed.size)
+    publish(ctx)
+  rescue StandardError => e
+    ctx.log.warn("mcp_tools_not_relisted", server: server.name, error: e.class.name, msg: e.message)
+  end
+
   # tools/list, every page.
   def list_tools(client, cancelled)
     tools = []
@@ -456,7 +526,7 @@ class Plugin
   def publish(ctx)
     @publish.synchronize do
       @chi.replace_tools do |set|
-        @servers.each { |server| declare(set, server, ctx) if %i[running cached].include?(server.state) }
+        @servers.each { |server| declare(set, server, ctx) if %i[running cached exited].include?(server.state) }
       end
     end
   end
@@ -483,7 +553,13 @@ class Plugin
   def call(server, tool, args, ctx)
     return "Error: MCP server #{server.name} didn't start: #{server.error}" if server.state == :failed
 
-    client = server.state == :cached ? lazy_start(server, ctx) : server.service.value
+    client = case server.state
+             when :cached then lazy_start(server, ctx)
+             when :exited then restart(server, ctx)
+             else
+               server.service.value # raises once stopped
+               server.client
+             end
     return client if client.is_a?(String)
 
     result = client.request("tools/call", { name: tool, arguments: args }, timeout: server.timeout,
@@ -529,6 +605,36 @@ class Plugin
     "Error: MCP server #{server.name} didn't start: #{e.message}"
   end
 
+  # Start a server that exited again, for a call: at most MAX_RESTARTS
+  # times a session. A start that fails or is cancelled leaves it exited
+  # (the next call tries again, while restarts are left).
+  # @return [Client, String] the client, or the call's error text
+  def restart(server, ctx)
+    @restart.synchronize do
+      server.service.value # raises once stopped
+      return server.client if server.state == :running # another call restarted it
+
+      if server.restarts >= MAX_RESTARTS
+        return "Error: MCP server #{server.name} is not running (#{server.error}; restarted #{MAX_RESTARTS} times this session)"
+      end
+
+      server.restarts += 1
+      cached = server.listed
+      server.client&.close
+      begin
+        client = spawn(server, ctx)
+      rescue StandardError => e
+        server.client&.close
+        ctx.log.warn("mcp_server_not_restarted", server: server.name, error: e.class.name, msg: e.message)
+        return "Error: MCP server #{server.name} didn't restart: #{e.message}"
+      end
+      server.state = :running
+      ctx.log.info("mcp_server_restarted", server: server.name, pid: client.pid, restarts: server.restarts)
+      publish(ctx) if server.listed != cached
+      client
+    end
+  end
+
   # The answer's text, and the images to attach: its image blocks, and a
   # text block that is only an image's path (#image_path).
   # @return [Array(String, Array<Hash>)]
@@ -541,11 +647,14 @@ class Plugin
       case block["type"]
       when "text"
         line = block["text"].to_s
-        path = image_path(line, server)
-        next line unless path
+        paths = image_paths(line, server).reject { |path| images.any? { |image| image[:path] == path } }
+        next line if paths.empty?
 
-        images << { path: path, name: File.basename(path) }
-        "#{line}\n[image #{images.size}: #{File.basename(path)}, attached]"
+        notes = paths.map do |path|
+          images << { path: path, name: File.basename(path) }
+          "[image #{images.size}: #{File.basename(path)}, attached]"
+        end
+        [line, *notes].join("\n")
       when "image"
         mime = block["mimeType"] || "unknown type"
         bytes = block["data"].to_s.unpack1("m")
@@ -564,14 +673,31 @@ class Plugin
     [text, images]
   end
 
-  # The path when +text+ is only the absolute path of an image file under
-  # the system temp dir or the server's cwd (a server's text can't pull
-  # in any image on disk), and the server's attach_image_paths isn't off.
-  def image_path(text, server)
-    return nil if server.config["attach_image_paths"] == false
+  # An absolute path ending in an image extension, inside a sentence
+  # ("Saved screenshot to /tmp/shot.png."): no spaces, quotes or brackets.
+  IMAGE_PATH_IN_TEXT = %r{(?<![\w/.~-])/[^\s"'`<>()\[\]{},;]+?\.(?:png|jpe?g|gif|webp)(?![\w/-])}i
+
+  # The images +text+ names, when the server's attach_image_paths isn't
+  # off: the whole text when it is one absolute path (any name), else each
+  # absolute path in it that ends in an image extension. Each must be an
+  # image file (by its bytes) under the system temp dir or the server's
+  # cwd: a server's text can't pull in any image on disk.
+  # @return [Array<String>] real paths, each once
+  def image_paths(text, server)
+    return [] if server.config["attach_image_paths"] == false
+
+    whole = text.strip
+    candidates = if whole.start_with?("/") && !whole.include?("\n") && File.file?(whole)
+                   [whole]
+                 else
+                   text.scan(IMAGE_PATH_IN_TEXT)
+                 end
+    candidates.filter_map { |path| image_path(path, server) }.uniq
+  end
 
-    path = text.strip
-    return nil unless path.start_with?("/") && !path.include?("\n") && File.file?(path)
+  # +path+'s real path when it is an image file under a root, else nil.
+  def image_path(path, server)
+    return nil unless File.file?(path)
 
     real = File.realpath(path)
     roots = [Dir.tmpdir, server.cwd].compact.map { |dir| File.realpath(dir) rescue nil }.compact
@@ -589,14 +715,20 @@ class Plugin
       (head.start_with?("RIFF") && head[8, 4] == "WEBP")
   end
 
-  # The process ended while chi runs: one notice; the calls say so.
+  # The process ended while chi runs: one notice; its next call starts it
+  # again (#restart) while restarts are left.
   def exited(server, reason, ctx)
     return unless server.state == :running
 
     server.state = :exited
     server.error = reason
-    ctx.log.warn("mcp_server_exited", server: server.name, msg: reason)
-    ctx.notify("MCP server #{server.name} stopped: #{reason}; its tools fail until chi restarts", level: :warn)
+    ctx.log.warn("mcp_server_exited", server: server.name, msg: reason, restarts: server.restarts)
+    after = if server.restarts < MAX_RESTARTS
+              "it restarts on its next call"
+            else
+              "it was restarted #{MAX_RESTARTS} times, its tools fail until chi restarts"
+            end
+    ctx.notify("MCP server #{server.name} stopped: #{reason}; #{after}", level: :warn)
   end
 
   def listing
@@ -614,7 +746,7 @@ class Plugin
     when :cached then "cached (not started), #{server.tools.size} tool#{"s" unless server.tools.size == 1}"
     when :running
       count = server.tools.count { |tool| tool["chi_name"] }
-      "running (pid #{server.service.value.pid}), #{count} tool#{"s" unless count == 1}"
+      "running (pid #{server.client.pid}), #{count} tool#{"s" unless count == 1}"
     when :starting then "starting"
     else "#{server.state == :failed ? "failed" : "stopped"}: #{server.error}"
     end

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

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

data/lib/samagotchi/config.rb

@@ -187,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
@@ -603,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
 
@@ -611,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
 
@@ -729,6 +746,10 @@ module Samagotchi
           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?)
@@ -794,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
 
@@ -935,7 +957,8 @@ 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.
@@ -1023,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/engine.rb

@@ -1362,8 +1362,10 @@ module Samagotchi
     # +ended+: the end event is out (what follows is post-turn work).
     # +settings+: the kernel's LLM::TurnSettings, made in #prepare_turn and
     # set on the kernel in #generate.
+    # +id+: names the turn on :turn_started (its metrics record's id) and on
+    # its saved prompt, so a UI pairs the two whatever left the conversation.
     Turn = Struct.new(:session, :prompt, :continue, :on_event, :controller, :origin, :started_at, :messages, :ended,
-                      :settings) do
+                      :settings, :id) do
       # The turn's boundary events carry the origin only when there is one,
       # so payloads stay unchanged for callers that don't pass it.
       def tag(event) = origin ? event.merge(origin: origin) : event
@@ -1478,7 +1480,8 @@ module Samagotchi
       @guardrail_wiring.begin_turn(origin)
 
       Turn.new(session: session, prompt: continue ? nil : prompt, continue: continue, on_event: on_event,
-               controller: effective_controller, origin: origin, started_at: Process.clock_gettime(Process::CLOCK_MONOTONIC))
+               controller: effective_controller, origin: origin, started_at: Process.clock_gettime(Process::CLOCK_MONOTONIC),
+               id: SecureRandom.uuid)
     end
     private :begin_turn
 
@@ -1492,7 +1495,7 @@ module Samagotchi
       image_refs, image_error = turn_image_refs(session, images)
       # Emit turn_started event
       bind_metrics(session)
-      turn_started = { type: :turn_started, session_id: session.id, prompt: turn.prompt }
+      turn_started = { type: :turn_started, session_id: session.id, prompt: turn.prompt, turn_id: turn.id }
       turn_started[:continue] = true if turn.continue
       turn_started[:images] = image_refs unless image_refs.empty?
       emit_event(turn.on_event, turn.tag(turn_started))
@@ -1565,7 +1568,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
 
@@ -1594,7 +1598,7 @@ module Samagotchi
 
       return if turn.continue
 
-      user_message = { role: "user", content: turn.prompt }
+      user_message = { role: "user", content: turn.prompt, turn_id: turn.id }
       user_message[:images] = image_refs unless image_refs.empty?
       turn.messages << user_message
       session.last_prompt = turn.prompt
@@ -1610,7 +1614,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,
@@ -2244,7 +2248,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

data/lib/samagotchi/guardrails/parent_approvals.rb

@@ -33,8 +33,11 @@ module Samagotchi
       # chi started there answers as a parent (#parent_process?).
       PARENT_SESSION_ENV = "SAMAGOTCHI_PARENT_SESSION"
       # Environment variables that say an agent runs this process: Claude
-      # Code's, and chi's own. They survive a PTY wrapper (script, expect).
-      AGENT_MARKERS = ["CLAUDECODE", "AI_AGENT", PARENT_SESSION_ENV].freeze
+      # Code's, the AI_AGENT convention, Codex CLI's (CODEX_THREAD_ID, which
+      # Codex sets on every command its shell tool runs), and chi's own.
+      # They survive a PTY wrapper (script, expect). The docs list them too
+      # (guardrails.md, sub-agent.md).
+      AGENT_MARKERS = ["CLAUDECODE", "AI_AGENT", "CODEX_THREAD_ID", PARENT_SESSION_ENV].freeze
       # Rules that ask about chi's own config and hooks: the core
       # ProtectedPaths asks and the guardrails bundle's shell rule.
       PROTECTED_RULES = %w[chi-config chi-hooks shell-touches-chi].freeze

data/lib/samagotchi/host_registry.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ipaddr"
 require_relative "config"
 require_relative "model_ref"
 require_relative "client"
@@ -31,9 +32,12 @@ module Samagotchi
     # first_token_timeout: the configured first-token limit (see #first_token_limit);
     # vision: the configured true/false (VisionSupport), nil when unset;
     # sampling: the configured request parameters (SamplingSettings), nil when unset;
-    # thinking: the configured level (Thinking), nil when unset.
+    # thinking: the configured level (Thinking), nil when unset;
+    # remote: the configured true/false (#remote?), nil when unset;
+    # window_tokens: the configured context window (ContextWindow.setting), nil when unset.
     HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
-                           :first_token_timeout, :vision, :sampling, :thinking, keyword_init: true) do
+                           :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
+                           keyword_init: true) do
       # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
       # raw-prompt loop.
       def chat? = api == :openai
@@ -45,9 +49,12 @@ module Samagotchi
       # configured, else the root's /v1.
       def openai_base_url = url || "#{root_url}/v1"
 
-      # A provider on the network rather than a local server: it needs a key
-      # or speaks https. Its model list is cached longer.
-      def remote? = !api_key_env.to_s.empty? || scheme == "https"
+      # A provider on the network rather than a local server: hosts.<name>.remote
+      # when set, else by its address (HostRegistry.remote_address?). An API
+      # key doesn't decide: a llama.cpp on the LAN can have one. A remote
+      # host's model list is cached longer, it gets a first-token limit, and
+      # it isn't asked for llama.cpp's /props.
+      def remote? = remote.nil? ? HostRegistry.remote_address?(scheme, host) : remote
 
       def models_ttl = remote? ? REMOTE_CACHE_TTL_SECONDS : CACHE_TTL_SECONDS
 
@@ -89,7 +96,8 @@ module Samagotchi
         entry = HostEntry.new(name: key.to_s.downcase, host: cfg[:host], port: cfg[:port].to_i, transport: transport,
                               api: cfg[:api]&.to_sym, scheme: cfg[:scheme], url: cfg[:url], api_key_env: cfg[:api_key_env],
                               profile: cfg[:profile], first_token_timeout: cfg[:first_token_timeout],
-                              vision: cfg[:vision], sampling: cfg[:sampling], thinking: cfg[:thinking])
+                              vision: cfg[:vision], sampling: cfg[:sampling], thinking: cfg[:thinking],
+                              remote: cfg[:remote], window_tokens: cfg[:window_tokens])
         entry.client = Client.new(host: cfg[:host], port: cfg[:port], transport: transport, scheme: cfg[:scheme],
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
                                   api_key_env: entry.api_key_env, env: env)
@@ -113,6 +121,23 @@ module Samagotchi
       @entries
     end
 
+    # 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
+                    ::1/128 fc00::/7 fe80::/10].map { |net| IPAddr.new(net) }.freeze
+
+    # Whether an address is remote: https, or an http IP address outside
+    # the local nets (LOCAL_NETS). An http host named by a name (localhost,
+    # box, mac.local, gpu.lan) counts as local: chi doesn't look names up.
+    def self.remote_address?(scheme, host)
+      return true if scheme.to_s == "https"
+
+      address = IPAddr.new(host.to_s.delete_prefix("[").delete_suffix("]"))
+      address = address.native if address.ipv4_mapped?
+      LOCAL_NETS.none? { |net| net.family == address.family && net.include?(address) }
+    rescue IPAddr::Error
+      false
+    end
+
     # server.first_token_timeout, or nil when unset or unreadable.
     def self.configured_first_token_timeout
       Config.get("server.first_token_timeout")