samagotchi 0.68.0 → 0.70.0

data/lib/samagotchi/kernel_loop.rb

@@ -21,6 +21,7 @@ require_relative "steer"
 require_relative "reasoning_history"
 require_relative "thought_stream_splitter"
 require_relative "tools/builtins"
+require_relative "tools/builtin_calls"
 require_relative "muted_memories"
 require_relative "tool_activity"
 require_relative "tool_runner"
@@ -177,6 +178,10 @@ module Samagotchi
     # a plugin tool's row refs resolve their files against (ToolRunner,
     # RowRefs); the Engine sets it. nil: the process's own (Dir.pwd).
     attr_accessor :session_cwd
+    # The session's folder (a callable → String or nil), where ToolRunner
+    # saves a cut output whole (ToolOutputFiles); the Engine sets it. nil:
+    # none (a bare kernel), the cut says the output wasn't saved.
+    attr_accessor :session_dir
     # Tools::Peers (or the Engine's live view of it): the session
     # list_sessions and send_note speak for; nil outside a session.
     attr_accessor :peers
@@ -1070,12 +1075,22 @@ module Samagotchi
     #
     # A tool the session's toolkit leaves out is a real one, so its error
     # does name it (deliberately, against the rule above): the model learns
-    # it exists and that only the user can load it.
-    def unknown_tool_error(name, layers)
+    # it exists, and how to reach it (call_tool, when the toolkit reaches
+    # it that way) or that only the user can load it. A call reached
+    # through call_tool (+via+) of a tool the toolkit declares is told to
+    # call it directly: the model's call_tool(tool: "chi/read") with read
+    # declared, or a hook's rewrite (a direct call can't carry via:).
+    def unknown_tool_error(name, layers, via: nil)
       names = @tools.names(layers: layers)
-      if @tools.respond_to?(:left_out) && @tools.left_out(name, layers: layers)
-        toolkit = @tools.toolkit&.name
-        "Error: #{name} isn't loaded in this session#{" (toolkit #{toolkit})" if toolkit} and can't be loaded from " \
+      toolkit = @tools.toolkit&.name
+      in_toolkit = " in this session#{" (toolkit #{toolkit})" if toolkit}"
+      if via && @tools.offered(name, layers: layers)
+        "Error: #{name} is declared#{in_toolkit}; call it directly. Available: #{names.join(", ")}"
+      elsif !via && @tools.respond_to?(:indexed) && @tools.indexed(name, layers: layers)
+        "Error: #{name} isn't declared#{in_toolkit}; call it with #{Tools::BuiltinCalls::VIA}(tool: \"chi/#{name}\", args: {…}) " \
+          "(find_tools gives its inputSchema). Available: #{names.join(", ")}"
+      elsif @tools.respond_to?(:left_out) && @tools.left_out(name, layers: layers)
+        "Error: #{name} isn't loaded#{in_toolkit} and can't be loaded from " \
           "here; only the user can (/toolkit add #{name}). Available: #{names.join(", ")}"
       elsif SHELL_LIKE_TOOL_NAMES.include?(name.to_s.downcase) && names.include?("execute")
         "Error: no such tool. Shell commands run with `execute` (same arguments)."
@@ -1085,9 +1100,15 @@ module Samagotchi
     end
 
     def dispatch(call)
-      entry = @tools.offered(call[:name], layers: llm_context_layers)
+      # A built-in reached through call_tool runs only while the toolkit
+      # reaches it that way (Registry#indexed); any other call by its name.
+      entry = if call[:via]
+                @tools.respond_to?(:indexed) ? @tools.indexed(call[:name], layers: llm_context_layers) : nil
+              else
+                @tools.offered(call[:name], layers: llm_context_layers)
+              end
       unless entry
-        result = unknown_tool_error(call[:name], llm_context_layers)
+        result = unknown_tool_error(call[:name], llm_context_layers, via: call[:via])
         return {
           output: result,
           activity: ToolActivity.tool_activity_event(call[:name], call, result, registry: @tools)
@@ -1112,6 +1133,12 @@ module Samagotchi
       }
       # Images the tool returned (read's ImageResult, a plugin's ToolResult):
       # ToolRunner attaches them (or says why not).
+      # A text that shows part of a file (Tools::RefText): the cut of a
+      # long one names that file (ToolRunner).
+      if result.respond_to?(:ref_path) && result.ref_path
+        dispatched[:ref_path] = result.ref_path
+        dispatched[:ref_stderr_path] = result.stderr_path if result.stderr_path
+      end
       if result.respond_to?(:images) && !Array(result.images).empty?
         dispatched[:images] = Array(result.images)
         dispatched[:image_only] = true if result.respond_to?(:image_only?) && result.image_only?

data/lib/samagotchi/llm/errors.rb

@@ -20,7 +20,8 @@ module Samagotchi
     # asking again could help.
     #
     #   ConnectionError  no answer (refused, reset, timeout); RetryExhausted,
-    #                    ConnectionRefused
+    #                    ConnectionRefused, TLSError (a handshake that can't
+    #                    work: certificate, host name, http vs https)
     #   RateLimited      429, with retry_after when the server says
     #   CreditsHeld      402 "… in-flight requests": credit reserved by other
     #                    requests; a RateLimited, retried after 20 s
@@ -271,6 +272,51 @@ module Samagotchi
       def summary = "can't reach host #{host}#{" at #{address}" if address} (connection refused) — is the server running?"
     end
 
+    # A TLS handshake that can't work however often it is tried: a
+    # certificate chi doesn't trust, a certificate for another name, or a
+    # server that doesn't speak TLS there (an https:// base_url on a plain
+    # HTTP port). Not retried. Any other OpenSSL::SSL::SSLError (an
+    # unexpected eof or a reset mid-handshake) is a network blip, retried.
+    class TLSError < ConnectionError
+      # problem => [pattern of the OpenSSL message, what to check]. The
+      # first match wins, so the host name comes before the general
+      # certificate check ("certificate verify failed (hostname mismatch)").
+      PROBLEMS = {
+        hostname: [/hostname mismatch|does not match the server certificate/i,
+                   "the certificate is for another name: check the host's base_url"],
+        certificate: [/certificate verify failed/i,
+                      "is its CA trusted? set SSL_CERT_FILE to a CA bundle that has it"],
+        scheme: [/wrong version number|packet length too long/i,
+                 "the server doesn't answer TLS there: should the host's base_url start with http://?"]
+      }.freeze
+
+      attr_reader :address, :problem, :reason
+
+      # The permanent problem an OpenSSL::SSL::SSLError's +message+ names
+      # (:hostname, :certificate, :scheme), or nil for a transient one.
+      def self.problem_for(message)
+        PROBLEMS.find { |_problem, (pattern, _hint)| pattern.match?(message.to_s) }&.first
+      end
+
+      # The OpenSSL reason without Ruby's "SSL_connect returned=1 errno=0
+      # peeraddr=… state=…: " prefix.
+      def self.reason_for(message)
+        message.to_s[/\bstate=[^:]*:\s*(.+)\z/m, 1] || message.to_s
+      end
+
+      def initialize(host:, problem:, reason:, address: nil, attempts: 1)
+        @address = address
+        @problem = problem
+        @reason = reason
+        super("#{host}: TLS failed#{" at #{address}" if address}: #{reason}", host: host, retryable: false,
+                                                                            attempts: attempts)
+      end
+
+      def summary
+        "can't reach host #{host}#{" at #{address}" if address} over TLS (#{reason}) — #{PROBLEMS.fetch(problem).last}"
+      end
+    end
+
     # A stream that showed nothing (no text, reasoning or tool call) within
     # the host's first-token limit. A queued request can stay open for many
     # minutes on keep-alive comments alone, which reset the read timeout.

data/lib/samagotchi/llm/http.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "net/http"
+require "openssl"
 require "uri"
 require_relative "../config"
 require_relative "../version"
@@ -31,9 +32,13 @@ module Samagotchi
       # the user, who can try again later.
       MAX_RETRY_AFTER = 60.0
 
+      # Errors that mean the request didn't get through (the probe treats
+      # them as "unreachable"). #retrying retries them, except a refused
+      # connection and a TLS error that can't work (.tls_problem).
       NETWORK_ERRORS = [
-        Timeout::Error, EOFError, SocketError, IO::TimeoutError,
-        Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ETIMEDOUT
+        Timeout::Error, EOFError, SocketError, IO::TimeoutError, OpenSSL::SSL::SSLError,
+        Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN,
+        Errno::ETIMEDOUT, Errno::EPIPE, Errno::EADDRNOTAVAIL
       ].freeze
 
       # Requests of these purposes are the ones a turn waits on (or, for the
@@ -77,6 +82,13 @@ module Samagotchi
         NETWORK_ERRORS.any? { |klass| error.is_a?(klass) }
       end
 
+      # The permanent TLS problem +error+ is (TLSError::PROBLEMS: :certificate,
+      # :hostname, :scheme), or nil: not a TLS error, or a transient one
+      # (an unexpected eof or a reset mid-handshake) worth retrying.
+      def self.tls_problem(error)
+        error.is_a?(OpenSSL::SSL::SSLError) ? TLSError.problem_for(error.message) : nil
+      end
+
       # The ProviderError an SSE line carries (llama.cpp's `error:` event, a
       # `data:` line with an `error` object), or nil.
       def self.sse_error(line, host:)
@@ -278,6 +290,12 @@ module Samagotchi
             if e.is_a?(Errno::ECONNREFUSED)
               raise ConnectionRefused.new(host: @label, address: current[:address], attempts: attempts)
             end
+            # Nor is a handshake that can't work (an untrusted certificate,
+            # another name's, a plain HTTP server): it fails the same way.
+            if (problem = self.class.tls_problem(e))
+              raise TLSError.new(host: @label, address: current[:address], problem: problem,
+                                 reason: TLSError.reason_for(e.message), attempts: attempts)
+            end
 
             delay = current[:streamed] ? nil : @retry_policy.delay_for(attempts)
             raise RetryExhausted.new(attempts: attempts, last_error: e, label: @label) if delay.nil?

data/lib/samagotchi/llm_context_stale.rb

@@ -8,6 +8,7 @@ require_relative "model_profile"
 require_relative "tool_call_parser"
 require_relative "tools/builtin_calls"
 require_relative "tools/tool_path"
+require_relative "tool_output_cut"
 
 module Samagotchi
   # The stale layer (LLMContextStrategy :stale): a file read that a later
@@ -191,11 +192,17 @@ module Samagotchi
         id = entry[:tool_call_id].to_s
         matches = id.empty? ? [] : batch.select { |call_id, _| call_id.to_s == id }
         call = matches.one? ? matches.first.last : nil
+        call &&= Tools::BuiltinCalls.unwrap_saved(call, entry[:content])
         texts = call && refs.size == 1 ? ToolResponse.runs_named(entry[:content], [call[:name]]) : nil
         return texts ? [[refs.first, call, texts.first.text]] : []
       end
 
+      # A call_tool of a built-in ran as it: its run's lead names the
+      # built-in (BuiltinCalls.unwrap_saved).
       calls = batch.map(&:last)
+      calls = calls.zip(ToolResponse.runs(entry[:content], calls.size)).map do |call, run|
+        Tools::BuiltinCalls.unwrap_saved(call, run&.text)
+      end
       texts = ToolResponse.runs_named(entry[:content], calls.map { |call| call[:name] })
       return [] unless texts && texts.size == refs.size
 
@@ -220,10 +227,9 @@ module Samagotchi
     # output ToolRunner cut at max_tool_output_chars: it doesn't hold all
     # the lines asked for, so it supersedes nothing.
     PREVIEW = "[TRUNCATED_PREVIEW_HEAD]"
-    CUT = /\[cut: \d+ of \d+ chars; read it in parts\]\z/
 
     def partial?(body)
-      body.start_with?("truncated=true") || body.include?(PREVIEW) || body.match?(CUT)
+      body.start_with?("truncated=true") || body.include?(PREVIEW) || body.match?(ToolOutputCut::HEAD_CUT)
     end
 
     # The lines a read asked for: from start_line (1) to end_line (the end).

data/lib/samagotchi/log_subscriber.rb

@@ -138,6 +138,7 @@ module Samagotchi
       log(:info, :tool_call_completed, iteration: event[:iteration], tool: event[:tool],
                                        ms: ms, waited_ms: (waited if waited.positive?),
                                        output_chars: output.length, truncated: event[:output_truncated] || nil,
+                                       saved: (true if event[:output_file]),
                                        error: tool_error?(output) || nil)
     end
 

data/lib/samagotchi/memory_bundle/manifest.rb

@@ -24,6 +24,9 @@ module Samagotchi
     #     file: plugin.rb
     #     sha256: sha256:0a1b...
     #   requires_chi: ">= 0.1.28"   # optional — a Gem::Requirement for chi's VERSION
+    #   requires_chi_next: true     # optional, shipped bundles — ignored here:
+    #                          #   `rake release:bump` raises requires_chi to
+    #                          #   the released chi (docs/releasing.md)
     #   needs:                 # optional — outside commands the memories rely on
     #     - command: gh        #   (checked on PATH, never installed; docs/memory.md)
     #       why: reads PRs     #   optional

data/lib/samagotchi/model_price.rb

@@ -15,8 +15,8 @@ module Samagotchi
 
       values = raw.is_a?(Hash) ? raw.transform_keys(&:to_s).slice(*ModelPrice::KEYS) : nil
       valid = values && values.key?("input") && values.key?("output") &&
-              # YAML's .inf and .nan are Floats too: JSON can't carry them
-              # (hosts_json_for_env would drop every host) and NaN poisons the sums.
+              # YAML's .inf and .nan are Floats too: an infinite price
+              # isn't one, and NaN poisons the sums.
               values.values.all? { |v| v.is_a?(Numeric) && v.finite? && !v.negative? }
       unless valid
         warn_once "Warning: #{where}.price needs input and output, each a number >= 0 (USD per 1M tokens); ignored"
@@ -45,8 +45,6 @@ module Samagotchi
       ((uncached * input) + (cached_tokens * cache_read) + (cache_write_tokens * cache_write) +
        (completion_tokens * output)) / 1e6
     end
-
-    def to_config = to_h.transform_keys(&:to_s)
   end
 
   # The keys a price may hold (config validation checks them too).

data/lib/samagotchi/peer_sources.rb

@@ -4,7 +4,7 @@ require_relative "context_sources"
 
 module Samagotchi
   # The attached context sources a loaded peer bundle declared as its
-  # peer's answers (chi.peer_source: claude-review, codex-review), with the
+  # peer's answers (chi.peer_source: claude-outbox, codex-outbox), with the
   # peer's name ("Claude"). In-process only: a source is a peer's because
   # the bundle's code says so, never because of what a source file holds,
   # which a pushing process can write. Uninstalling the bundle ends it.

data/lib/samagotchi/plugin/api.rb

@@ -299,11 +299,12 @@ module Samagotchi
       end
 
       # A context source that holds a peer agent's answers (the peer
-      # bundles' claude-review, codex-review): +label+ is the peer's name
+      # bundles' claude-outbox, codex-outbox): +label+ is the peer's name
       # ("Codex", PeerSources::LABEL), said in chi's own lines. Such a
       # source, when it is a pushed one of the session's own, wakes on
       # context.peer_turns rather than the 10-minute window, with the peer
-      # line (docs/context.md, Waking). Declared here, in-process, never by
+      # line, or the closing line for an answer that agrees (docs/context.md,
+      # Waking). Declared here, in-process, never by
       # a source file; gone with the bundle.
       def peer_source(name, label:)
         raise ArgumentError, "this chi has no peer sources (plugins: false)" unless @registries.peer_sources

data/lib/samagotchi/plugin/peer.rb

@@ -12,7 +12,7 @@ module Samagotchi
     # docs/plugins.md): a live link between a chi session and another agent's
     # session the user works with. The peer pairs (its chi-peer skill,
     # scripts/pair): it attaches the `<peer>-inbox` context, whose hint says
-    # where to send (a subclass's #check_hint!), and `<peer>-review`, where
+    # where to send (a subclass's #check_hint!), and `<peer>-outbox`, where
     # its answers come back as pushes that wake chi.
     #
     # The `<peer>_send` tool sends a part of the work (a plan step, a diff, a
@@ -40,7 +40,7 @@ module Samagotchi
     # `From your thinking:` label.
     #
     # A subclass (the bundle's Plugin) sets the strings, as constants:
-    # INBOX, REVIEW ("<peer>-inbox", "-review"), BUNDLE, NAME (the peer, as
+    # INBOX, OUTBOX ("<peer>-inbox", "-outbox"), BUNDLE, NAME (the peer, as
     # the model and user call it: "Claude"), APP (its product: "Claude
     # Code"), COMMAND ("/claude"), TOOL, TOOL_DESCRIPTION, TOOL_PARAMS,
     # USAGE, STATUS_CARD, SKILL_CARD, CHECKED_ON and SCRIPTS_DIRS (beside the
@@ -90,9 +90,9 @@ module Samagotchi
         end
         # A chi without chi.annotation (before 0.66) loads the bundle without the pill.
         chi.annotation "Confirm with #{peer::NAME}", command: "#{peer::COMMAND} validate" if chi.respond_to?(:annotation)
-        # The review source is the peer's answers: its own wake budget and
+        # The outbox source is the peer's answers: its own wake budget and
         # line (context.peer_turns). A chi before 0.67 has no peer_source.
-        chi.peer_source peer::REVIEW, label: peer::NAME if chi.respond_to?(:peer_source)
+        chi.peer_source peer::OUTBOX, label: peer::NAME if chi.respond_to?(:peer_source)
         chi.on(:before_turn) do |event|
           @lock.synchronize { @before_turn = Array(event[:messages]) }
         end
@@ -172,7 +172,7 @@ module Samagotchi
 
       def send_text(ctx, kind, text)
         "#{deliver(ctx, kind: kind, title: text_title(text), text: text)}; #{self.class::NAME}'s answer comes as the " \
-          "#{self.class::REVIEW} context"
+          "#{self.class::OUTBOX} context"
       rescue SendError => e
         "#{self.class::COMMAND}: #{e.message}"
       end
@@ -240,7 +240,7 @@ module Samagotchi
         peer = self.class
         id = ctx.session_id
         sources = id ? sources(ctx) : []
-        inbox, review = [peer::INBOX, peer::REVIEW].map { |name| sources.find { |source| source[:name] == name } }
+        inbox, outbox = [peer::INBOX, peer::OUTBOX].map { |name| sources.find { |source| source[:name] == name } }
         hint = inbox && inbox[:hint].to_s.strip
         paired = !(hint.nil? || hint.empty?)
         lines = if paired
@@ -250,7 +250,8 @@ module Samagotchi
                    "#{peer::NAME} \"pair with chi #{id.to_s[0, 8]}\"."]
                 end
         lines << "last send: #{last_send_line(ctx, id)}" if id && last_send(ctx, id)
-        lines << "last answer (#{peer::REVIEW}): #{review_line(review)}" if review
+        lines << "last answer (#{peer::OUTBOX}): #{outbox_line(outbox)}" if outbox
+        lines << "skill: **differs from this bundle's**: #{peer::COMMAND} install-skill (Replace), then pair again" if skill_differs?(ctx)
         lines << transport_line
         ctx.card(id: peer::STATUS_CARD, title: "#{peer::BUNDLE}: #{paired ? "paired" : "not paired"}",
                  body: lines.join("\n\n"), actions: [{ label: "Refresh", command: peer::COMMAND },
@@ -271,10 +272,10 @@ module Samagotchi
         "#{ago(sent["at"])} · #{sent["kind"]} · #{sent["title"]} (#{sent["chars"]} chars, #{where})"
       end
 
-      def review_line(review)
-        return "none yet" unless review[:fetched_at]
+      def outbox_line(outbox)
+        return "none yet" unless outbox[:fetched_at]
 
-        [review[:summary], ago(review[:fetched_at])].compact.join(" · ")
+        [outbox[:summary], ago(outbox[:fetched_at])].compact.join(" · ")
       end
 
       def ago(stamp)
@@ -291,14 +292,32 @@ module Samagotchi
       # /<peer> install-skill [--yes]
       def install_skill(ctx, yes:)
         peer = self.class
-        source = peer::SCRIPTS_DIRS.map { |dir| File.join(dir, SKILL_FILE) }.find { |path| File.file?(path) }
-        return "#{peer::COMMAND} install-skill: this bundle has no scripts/#{SKILL_FILE}; reinstall it (chi bundle install #{peer::BUNDLE} --force)" unless source
+        target, text = skill_target_and_text(ctx)
+        return "#{peer::COMMAND} install-skill: this bundle has no scripts/#{SKILL_FILE}; reinstall it (chi bundle install #{peer::BUNDLE} --force)" unless text
+
+        yes ? write_skill(ctx, target, text) : skill_card(ctx, target, text)
+      end
+
+      # Where install-skill writes the peer's skill and what it writes:
+      # [target, text]; the text nil when the bundle has no skill file.
+      def skill_target_and_text(ctx)
+        target = File.join(peer_dir, "skills", "chi-peer", "SKILL.md")
+        source = self.class::SCRIPTS_DIRS.map { |dir| File.join(dir, SKILL_FILE) }.find { |path| File.file?(path) }
+        return [target, nil] unless source
 
         substitutions = { PAIR_PLACEHOLDER => File.join(File.dirname(source), "pair"),
                           PAYLOADS_PLACEHOLDER => tilde(ctx.data_dir) }.merge(skill_substitutions(ctx))
-        text = substitutions.reduce(File.read(source)) { |skill, (placeholder, value)| skill.gsub(placeholder, value) }
-        target = File.join(peer_dir, "skills", "chi-peer", "SKILL.md")
-        yes ? write_skill(ctx, target, text) : skill_card(ctx, target, text)
+        [target, substitutions.reduce(File.read(source)) { |skill, (placeholder, value)| skill.gsub(placeholder, value) }]
+      end
+
+      # Whether the peer's installed skill isn't what install-skill would
+      # write (an older bundle's, or the user's edit): the status card says
+      # so. Not installed, or unreadable: no.
+      def skill_differs?(ctx)
+        target, text = skill_target_and_text(ctx)
+        text && File.file?(target) && File.read(target) != text
+      rescue SystemCallError
+        false
       end
 
       def skill_card(ctx, target, text)
@@ -351,7 +370,7 @@ module Samagotchi
       def follow_up(kind)
         case kind
         when "context" then "#{self.class::NAME} takes it in; it answers only if something in it is wrong."
-        else "#{self.class::NAME}'s answer comes as an update of the #{self.class::REVIEW} context; don't wait or poll."
+        else "#{self.class::NAME}'s answer comes as an update of the #{self.class::OUTBOX} context; don't wait or poll."
         end
       end
 

data/lib/samagotchi/session_metrics.rb

@@ -852,6 +852,9 @@ module Samagotchi
 
         called_as = event.dig(:activity, :called_as)
         active[:called_as] = called_as.to_s if called_as
+        # Reached through call_tool: the reloaded row says so (not an alias).
+        via = event.dig(:activity, :via)
+        active[:via] = via.to_s if via
         # A grep that found nothing (ok): the reloaded web row says "no match".
         active[:no_match] = true if event.dig(:activity, :no_match)
         finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i)
@@ -861,7 +864,7 @@ module Samagotchi
     # Caller holds the mutex.
     def finish_tool_record(active, status, waited_ms: 0)
       record = active.slice(
-        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :no_match, :started_at
+        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :via, :no_match, :started_at
       ).merge(
         status: status,
         completed_at: now.iso8601(3),

data/lib/samagotchi/system_prompt.rb

@@ -331,7 +331,9 @@ module Samagotchi
     # The tools the session's toolkit leaves out, named once right after the
     # base prompt: sessions on another toolkit already differ at the tools,
     # and nothing later (a memory write) moves it. nil when none are (full):
-    # the prompt is what it was before toolkits.
+    # the prompt is what it was before toolkits. The ones call_tool reaches
+    # and the ones the toolkit removes (only the user brings those back)
+    # get a sentence each; with call_tool not declared, one list.
     def not_loaded_line(layers)
       registry = @tools_lookup.call
       return nil unless registry.respond_to?(:left_out_names)
@@ -339,8 +341,22 @@ module Samagotchi
       names = registry.left_out_names(layers: layers)
       return nil if names.empty?
 
-      "Not loaded in this session (toolkit #{registry.toolkit&.name}): #{names.join(", ")}. " \
-        "Only the user can load one (/toolkit add <name>)."
+      toolkit = "(toolkit #{registry.toolkit&.name})"
+      reachable = registry.reachable_names(layers: layers)
+      if reachable.empty?
+        return "Not loaded in this session #{toolkit}: #{names.join(", ")}. Only the user can load one (/toolkit add <name>)."
+      end
+
+      removed = names - reachable
+      # find_tools removed (call_tool still works): the route without it.
+      how = if removed.include?("find_tools") then "Call one with call_tool(tool: \"chi/<name>\", args: {…})."
+            else "Search them with find_tools; call one with call_tool."
+            end
+      line = "Not declared in this session #{toolkit}: #{reachable.join(", ")}. #{how}"
+      return line if removed.empty?
+
+      "#{line} Removed #{toolkit}: #{removed.join(", ")}. Only the user can load #{removed.size == 1 ? "it" : "one"} " \
+        "(/toolkit add <name>)."
     end
 
     def with_tail_declarations(prompt, chat:, layers:)

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -34,7 +34,8 @@ module Samagotchi
       # What a tool line says the call did: the model's description of a
       # command (": List the specs") in place of its cut params, else the
       # params, dim; then, dim, the name the model called it by when that was
-      # an alias's (" (called as bash)").
+      # an alias's (" (called as bash)"), or the tool it was reached through
+      # (" (via call_tool)").
       def tool_params_suffix(activity)
         description = activity[:description].to_s.strip
         params = activity[:params].to_s.strip
@@ -43,7 +44,9 @@ module Samagotchi
                  else ""
                  end
         called_as = activity[:called_as].to_s
-        called_as.empty? ? suffix : "#{suffix}#{paint(" (called as #{called_as})", 90)}"
+        suffix = "#{suffix}#{paint(" (called as #{called_as})", 90)}" unless called_as.empty?
+        via = activity[:via].to_s
+        via.empty? ? suffix : "#{suffix}#{paint(" (via #{via})", 90)}"
       end
 
       # Green ok, yellow stopped (a wait the user's Stop ended), red the rest.

data/lib/samagotchi/tool_activity.rb

@@ -56,6 +56,9 @@ module Samagotchi
       # The name the model used when an alias ran a built-in (called_as: "bash"
       # for an execute), for a UI that shows it.
       event[:called_as] = call[:called_as] if call.is_a?(Hash) && call[:called_as]
+      # The tool it was reached through (via: "call_tool", a built-in the
+      # toolkit doesn't declare): not an alias, the model named it.
+      event[:via] = call[:via] if call.is_a?(Hash) && call[:via]
       # The model's own words for a command, which the TUI's tool line
       # shows in place of the cut params.
       description = command_description(tool_name, call)