samagotchi 0.70.0 → 0.72.0

data/lib/samagotchi/host_config.rb

@@ -33,7 +33,7 @@ module Samagotchi
       super(**members.to_h { |m| [m, nil] }, models: {}, **fields)
     end
 
-    # A hosts: entry as written (YAML, or a SAMAGOTCHI_HOSTS_JSON override),
+    # A hosts: entry as written in config.yml,
     # or nil when it is disabled (enabled: false) or invalid. An invalid
     # one warns once, naming the entry, the way each reader of a setting
     # does for a bad value (that value is then unset).

data/lib/samagotchi/host_keys.rb

@@ -131,8 +131,6 @@ module Samagotchi
       # The command that stores the key for +name+ (prompting for it).
       def store_command(name) = "security add-generic-password -s #{SERVICE} -a #{name} -w"
 
-      def clear_cache! = @mutex.synchronize { @cache.clear }
-
       # Names only: the cache holds keys.
       def inspect = "#<#{name} cached=#{@mutex.synchronize { @cache.keys }.inspect}>"
 

data/lib/samagotchi/paths.rb

@@ -28,5 +28,18 @@ module Samagotchi
       xdg = env.fetch("XDG_CONFIG_HOME", "").to_s.strip
       xdg.empty? ? File.expand_path("~/.config") : xdg
     end
+
+    # +path+ as chi shows it: ~ for the home folder (~/a for one in it),
+    # else as it is; as it is too when there's no home (HOME unset).
+    # @return [String]
+    def tilde(path)
+      path = path.to_s
+      home = Dir.home
+      return "~" if path == home
+
+      path.start_with?("#{home}/") ? "~#{path.delete_prefix(home)}" : path
+    rescue ArgumentError
+      path
+    end
   end
 end

data/lib/samagotchi/plugin/api.rb

@@ -279,13 +279,19 @@ module Samagotchi
 
       # A named toolkit sessions can be put on (/toolkit NAME, chi --toolkit,
       # toolkit.default, ctx.use_toolkit): +base+'s tools (a toolkit chi or
-      # a bundle has) with +add+ declared and +remove+ left out. A name chi
-      # (full, lean, child) or another bundle has is a load error; a base
-      # that doesn't resolve leaves the sessions on it with every tool
+      # a bundle has) with +add+ declared and +remove+ left out, and
+      # +prompt+: text the sessions on it get in their system prompt (nil:
+      # its base's, "" none; at most Toolkit::PROMPT_MAX characters). A
+      # name chi (full, lean, child) or another bundle has is a load error,
+      # and so is a prompt that isn't text or is too long; a base that
+      # doesn't resolve leaves the sessions on it with every tool
       # (Toolkit#resolve).
-      def toolkit(name, base:, add: [], remove: [])
+      def toolkit(name, base:, add: [], remove: [], prompt: nil)
         name = name.to_s
         raise ArgumentError, "toolkit name #{name.inspect} must be a-z, 0-9, _ and -" unless name.match?(TOOLKIT_NAME)
+
+        problem = Toolkit.prompt_error(prompt)
+        raise ArgumentError, "toolkit #{name}: #{problem}" if problem
         raise ArgumentError, "this chi has no toolkits (plugins: false)" unless @registries.toolkits
         if Toolkit::BUILTIN_KITS.key?(name)
           raise ArgumentError, "toolkit #{name} is chi's own"
@@ -294,7 +300,7 @@ module Samagotchi
         end
         raise ArgumentError, "toolkit #{name} is declared twice" if @toolkits.any? { |kit| kit.name == name }
 
-        @toolkits << Toolkit::Kit.new(name: name, base: base, add: add, remove: remove, source: @bundle)
+        @toolkits << Toolkit::Kit.new(name: name, base: base, add: add, remove: remove, prompt: prompt, source: @bundle)
         nil
       end
 

data/lib/samagotchi/plugin/peer.rb

@@ -5,6 +5,7 @@ require "json"
 require "open3"
 require "tempfile"
 require "time"
+require_relative "../paths"
 
 module Samagotchi
   module Plugin
@@ -88,11 +89,10 @@ module Samagotchi
                                    "it; install-skill: install #{peer::NAME}'s chi-peer skill", anytime: true do |args, ctx|
           run_command(args.to_s.strip, ctx)
         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)
+        chi.annotation "Confirm with #{peer::NAME}", command: "#{peer::COMMAND} validate"
         # 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::OUTBOX, label: peer::NAME if chi.respond_to?(:peer_source)
+        # line (context.peer_turns).
+        chi.peer_source peer::OUTBOX, label: peer::NAME
         chi.on(:before_turn) do |event|
           @lock.synchronize { @before_turn = Array(event[:messages]) }
         end
@@ -362,10 +362,7 @@ module Samagotchi
         "(diff isn't there to show how)"
       end
 
-      def tilde(path)
-        home = Dir.home
-        path.start_with?("#{home}/") ? "~#{path.delete_prefix(home)}" : path
-      end
+      def tilde(path) = Paths.tilde(path)
 
       def follow_up(kind)
         case kind

data/lib/samagotchi/prompt_files.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "memory_paths"
+require_relative "paths"
 
 module Samagotchi
   # The files whose text goes into the system prompt as they are
@@ -76,10 +77,7 @@ module Samagotchi
       rel = top && relative_dir(path, top)
       return rel if rel && rel != "."
 
-      home = Dir.home
-      path.start_with?("#{home}/") ? "~#{path.delete_prefix(home)}" : path
-    rescue ArgumentError
-      path
+      Paths.tilde(path)
     end
 
     # A chi --append-system-prompt value: [absolute path, nil], or

data/lib/samagotchi/session.rb

@@ -189,7 +189,8 @@ module Samagotchi
     # which is on Toolkit::FULL (Toolkit.of). Saved and never resolved
     # again from config, so a respawned worker declares the same tools; a
     # continue and a fork copy it (SessionSetup.of), a delegate child gets
-    # toolkit.child (SessionManager.spawn_session).
+    # the one its delegate call named, else toolkit.child
+    # (SessionManager.spawn_session).
     attr_reader :toolkit
 
     # @param value [Toolkit, Hash, String, nil] the session file's form too

data/lib/samagotchi/session_manager.rb

@@ -140,9 +140,10 @@ module Samagotchi
     # @param title [String, nil] what the lists show before the first turn
     #   (the prompt's preview by default, else the seed's first user message)
     # @param setup [SessionSetup] the session's own settings (chi
-    #   --llm-context; a fork and a continue copy their session's); without
-    #   a toolkit the session is stored on config's toolkit.default, a
-    #   delegate child always on toolkit.child (Toolkit.configured)
+    #   --llm-context; a fork and a continue copy their session's; a delegate
+    #   child the toolkit its delegate call named); without a toolkit the
+    #   session is stored on config's toolkit.default, a delegate child on
+    #   toolkit.child (Toolkit.configured)
     # @param continues [String, nil] the session this one continues (a
     #   session field; SessionContinue)
     # @param note [String, nil] a context note the session starts with,
@@ -179,7 +180,7 @@ module Samagotchi
         setup: setup,
         continues: continues
       )
-      session.toolkit = Toolkit.configured(delegate: delegate) if delegate || session.toolkit.nil?
+      session.toolkit = Toolkit.configured(delegate: delegate) if session.toolkit.nil?
       session.model_warning = model_warning
       # With no prompt there is no first turn to run (an attaching UI sends
       # the prompts), so the session starts idle.
@@ -209,8 +210,7 @@ module Samagotchi
     # is when the worker starts); opts[:env] adds to it (merged, not
     # replaced) what it can't read there: this `chi`'s CLI settings
     # (Config.cli_env) and the absolute log file. It unsets
-    # SAMAGOTCHI_GUARDRAILS_*, the session markers (SESSION_MARKER_ENV) and
-    # SAMAGOTCHI_HOSTS_JSON (HOSTS_JSON_ENV).
+    # SAMAGOTCHI_GUARDRAILS_* and the session markers (SESSION_MARKER_ENV).
     # XDG_CONFIG_HOME passes: whoever starts or
     # wakes the worker picks which config.yml it reads (docs/guardrails.md).
     private_class_method def self.spawn_options(session)
@@ -227,12 +227,6 @@ module Samagotchi
         Log.warn(:worker, "cwd_gone", sid: session.id, dir: dir, cwd: Dir.pwd)
       end
       child_env = {}
-      # The worker reads config.yml's hosts: as it starts, like every other
-      # setting: a host added or changed after this process (a parent
-      # worker, `chi web`) started reaches it. Unset, not just left out: a
-      # worker an older chi started still has one, and its delegates would
-      # inherit its start-time hosts.
-      child_env[HOSTS_JSON_ENV] = nil
       # A worker gets no CLI args: --model, --thinking, --log-level and the
       # other flags this chi was started with.
       child_env.merge!(Config.cli_env)
@@ -716,10 +710,6 @@ module Samagotchi
       wait_for_owner_release(session_id, timeout: wait, state_dir: sd) if wait
     end
 
-    # ConfigFile.hosts_config's override of config.yml's hosts:, which no
-    # spawned worker inherits (spawn_options).
-    HOSTS_JSON_ENV = "SAMAGOTCHI_HOSTS_JSON"
-
     STOP_CANCEL_WAIT = 3.0
     # The cancel reason of a turn a session stop cancels (Bridge::CANCEL_REASONS):
     # not the user's Stop, which only ends the turn ("user").

data/lib/samagotchi/session_model_settings.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require_relative "context_status"
+require_relative "effective_model"
+require_relative "sampling_settings"
+require_relative "session_setting"
+require_relative "steer_cut"
+require_relative "steer_cut_after"
+require_relative "thinking"
+
+module Samagotchi
+  # The session's settings on its effective model, as the Engine reads them:
+  # the session's own thinking, reasoning_history and llm_context values
+  # (SessionSetting) over the effective model's (EffectiveModel), the
+  # summaries /model and /stats show, and what the next turn resolves.
+  # Every read resolves the model again (EffectiveModel.of, never kept); a
+  # reader with a fallback gives it when the model doesn't resolve
+  # (#model_setting). The Engine forwards its public readers here.
+  class SessionModelSettings
+    # @param registry [HostRegistry] the Engine's (never replaced)
+    # @param choice   [#call] → the ModelChoice turns run on now (/model moves it)
+    # @param session  [#call] → the Engine's Session, nil before one
+    def initialize(registry:, choice:, session:)
+      @registry = registry
+      @choice = choice
+      @session = session
+    end
+
+    # The effective model now (EffectiveModel.of): resolved on each call,
+    # never kept (config.yml, a model listing and another process's saved
+    # lists all move a resolve). Raises as HostRegistry#resolve does.
+    # @return [EffectiveModel]
+    def effective_model(choice = @choice.call) = EffectiveModel.of(@registry, choice)
+
+    # The block's answer for the effective model, or +fallback+ when the
+    # model doesn't resolve: the readers whose rescue always covered the
+    # resolve too. Each setting's own failure is the EffectiveModel's.
+    def model_setting(fallback)
+      # One read: the log line names the model that failed, even if a
+      # /model switched it meanwhile.
+      choice = @choice.call
+      model = begin
+        effective_model(choice)
+      rescue StandardError => e
+        return EffectiveModel::Unresolved.fallback(:effective_model_unresolved, choice.name, e, fallback)
+      end
+      yield model
+    end
+
+    # The status line's ctx from the saved context, for a worker that has run
+    # no turn yet (it woke after an idle exit): nil when either count is
+    # unknown or context.status is off. Counted as the turns count it:
+    # against the effective model's llm_context budget when it has one.
+    def saved_context_status(context, model: :current)
+      return nil unless context
+
+      llm_context = model == :current ? turn_llm_context : model&.llm_context_explained(llm_context_session_args)&.resolved
+      ContextStatus.new(llm_context: llm_context)
+                   .display_for(used_tokens: context[:used_tokens], window_tokens: context[:window_tokens])
+    end
+
+    # #turn_llm_context with where each value came from
+    # (LLMContextStrategy.explain), nil when it can't be resolved.
+    # @return [LLMContextStrategy::Explained, nil]
+    def llm_context_explained
+      model_setting(nil) { |model| model.llm_context_explained(llm_context_session_args) }
+    end
+
+    # #llm_context_explained's summary (Explained#summary), nil when it
+    # can't be resolved: /stats, the snapshot, the web's info bar.
+    # @return [Hash, nil]
+    def llm_context_summary
+      llm_context_explained&.summary(llm_context_override)
+    end
+
+    # The session's own llm_context values, nil when it has none.
+    # @return [LLMContextOverride, nil]
+    def llm_context_override = SessionSetting::LLM_CONTEXT.own(@session.call)
+
+    # The effective model is on a chat host (api: openai or anthropic), whose loop uses
+    # no prompt profile.
+    def chat_model? = effective_model.chat?
+
+    # "temperature=0.6 (hosts.work)" for /model: the effective model's
+    # configured sampling, nil when none.
+    def sampling_summary = model_setting(nil, &:sampling_summary)
+
+    # "off (models: qwen)", "low (session)" for /model: the effective
+    # model's thinking level and where it came from, nil when none is set.
+    def thinking_summary
+      explained = thinking_explained
+      explained&.source ? explained.label : nil
+    end
+
+    # The seconds a cut waits for the effective model to stream only
+    # thinking (SteerCutAfter.resolve), resolved on every call, as
+    # turn_sampling; on any error, the global and its name.
+    # @return [Array(Integer, String|nil)]
+    def steer_cut_after_explained
+      model_setting([SteerCut.cut_after, "steer.cut_after"], &:steer_cut_after_explained)
+    end
+
+    # #steer_cut_after_explained's seconds: what SteerCut#cut_for_steer
+    # reads, per host and model.
+    def steer_cut_after = steer_cut_after_explained.first
+
+    # "after 60 s (models: qwen)", "never (hosts.splash)" for /model: the
+    # effective model's cut wait and where it came from, nil for the
+    # default.
+    def steer_cut_summary
+      seconds, source = steer_cut_after_explained
+      source ? SteerCutAfter.label(seconds, source) : nil
+    end
+
+    # The effective model's thinking level with where it came from and the
+    # session's own (SettingExplained), as the next turn resolves it;
+    # nil when it can't be resolved.
+    # @return [SettingExplained, nil]
+    # +own+: the session's own level to resolve with (the current one by
+    # default; /thinking asks what a change would resolve to).
+    def thinking_explained(own: thinking_override)
+      model_setting(nil) { |model| model.thinking_explained(own: own) }
+    end
+
+    # "drop (models: qwen)" for /model: the effective chat model's
+    # reasoning_history level and where it came from; nil when it is the
+    # default, the model runs on the native loop (which ignores it) or it
+    # can't be resolved.
+    def reasoning_history_summary
+      model_setting(nil) { |model| model.reasoning_history_summary(own: reasoning_history_override) }
+    end
+
+    # The effective chat model's reasoning_history level with where it came
+    # from and the session's own (SettingExplained), as the next turn
+    # resolves it; nil on a native host (the native loop ignores it; native:
+    # true resolves it there too, for /reasoning-history) or when it can't
+    # be resolved.
+    # @return [SettingExplained, nil]
+    # +own+: the session's own level to resolve with (the current one by
+    # default; a command asks what a change would resolve to).
+    def reasoning_history_explained(native: false, own: reasoning_history_override)
+      model_setting(nil) { |model| model.reasoning_history_explained(own: own, native: native) }
+    end
+
+    # What a reasoning_history change from level +from+ to level +to+ costs
+    # the effective model's prompt cache, given the session's conversation
+    # (ReasoningHistory.cache_cost): :history or nil. A host ChatLoop
+    # marked as refusing it may still get :history (one needless ask).
+    # @return [Symbol, nil]
+    def reasoning_history_cache_cost(from, to)
+      model_setting(nil) { |model| model.reasoning_history_cache_cost(from, to, conversation: @session.call&.messages) }
+    end
+
+    # The session's own reasoning_history level, nil when it has none.
+    # @return [Symbol, nil]
+    def reasoning_history_override = SessionSetting::REASONING_HISTORY.own(@session.call)
+
+    # Set the session's own reasoning_history level (nil unsets it); the
+    # next turn's start resolves it. The caller saves the session.
+    # @raise [ArgumentError] with no session yet
+    def reasoning_history_override=(level)
+      session = @session.call
+      raise ArgumentError, "no session yet" unless session
+
+      SessionSetting::REASONING_HISTORY.set(session, level)
+    end
+
+    # The session's own thinking level, nil when it has none.
+    # @return [Symbol, nil]
+    def thinking_override = SessionSetting::THINKING.own(@session.call)
+
+    # Set the session's own thinking level (nil unsets it); the next turn's
+    # start resolves it, never a running one (its TurnSettings are fixed).
+    # The caller saves the session.
+    # @raise [ArgumentError] with no session yet
+    def thinking_override=(level)
+      session = @session.call
+      raise ArgumentError, "no session yet" unless session
+
+      SessionSetting::THINKING.set(session, level)
+    end
+
+    # The host whose hosts.<name>.models.<id>.served names +served+ for the
+    # current model (a gateway's round-robin targets): not a mismatch to
+    # warn about. nil when none does.
+    # @return [String, nil]
+    def served_expected_by(served)
+      model_setting(nil) { |model| model.served_expected_by(served) }
+    end
+
+    def served_expected?(served) = !served_expected_by(served).nil?
+
+    # The effective model's request parameters (hosts: and models:
+    # sampling), read per turn: /model can change the model between turns.
+    def turn_sampling = model_setting(SamplingSettings::EMPTY, &:sampling)
+
+    # The effective model's thinking level (Thinking.resolve), read each turn.
+    def turn_thinking = model_setting(Thinking::DEFAULT) { |model| thinking_level(model) }
+
+    # +model+'s ReasoningHistory level, the session's own first; the
+    # default when it can't be resolved.
+    def reasoning_history_level(model) = model.reasoning_history(own: reasoning_history_override)
+
+    # +model+'s thinking level (Thinking.resolve), the session's own first.
+    def thinking_level(model) = model.thinking(own: thinking_override)
+
+    # The effective model's models:/hosts: window_tokens, read per turn
+    # (after the hooks that may switch the model).
+    def turn_window_setting = model_setting(nil, &:window_setting)
+
+    # The effective model's price on its host (hosts.<name>.models.<id>.price),
+    # by the requested id, never the served one; read per turn as the window is.
+    def turn_price = model_setting(nil, &:price)
+
+    # The LLM context strategy the next turn runs under: the session's own
+    # (Session#llm_context), else the effective model's (models:/hosts:
+    # llm_context_strategy), else llm_context.strategy; read per turn as
+    # the window is.
+    def turn_llm_context
+      llm_context_explained&.resolved
+    end
+
+    # The session's own llm_context values as LLMContextStrategy's
+    # arguments ({} without a session or values).
+    def llm_context_session_args = @session.call&.llm_context&.resolve_args || {}
+  end
+end

data/lib/samagotchi/session_setup.rb

@@ -19,7 +19,8 @@ module Samagotchi
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
-  # without one; a continue and a fork copy their session's (.of).
+  # without one (but the toolkit its delegate call named); a continue and a
+  # fork copy their session's (.of).
   SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit) do
     def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil)
       super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,

data/lib/samagotchi/sessions_command.rb

@@ -37,7 +37,8 @@ module Samagotchi
         archive ID...   # hide sessions (and their delegates) from every list and keep them for good; unarchive ID... brings them back
         delete [--force] ID...   # delete sessions for good (IDs or unique prefixes); --force stops a live worker first
         prune [--dry-run] [--days N] [--keep N] [--keep-status running,...] [--test-only]
-        clean [--dry-run] [--days N]   # test sessions (SAMAGOTCHI_ENV=test, CI) and leftover chi scratch ones: all of them, or those older than N days
+        clean [--dry-run] [--days N] [--all]   # test sessions (SAMAGOTCHI_ENV=test, CI) and leftover chi scratch ones: all of them, or those older than N days
+             --all: every session, not only test and scratch ones (by the age and count limits, as prune)
         stats ID [--format text|json]   # a session's cost, tokens and progress, without running a model turn:
              a live worker's GET stats, else the snapshot its saved analytics.json rebuilds (never starts a worker)
       Defaults: days=14 keep=500 keep_status=none (config: session.retention_days, session.max_count, session.keep_status)
@@ -107,6 +108,8 @@ module Samagotchi
       return parsed if parsed.is_a?(Integer)
 
       @opts = integers(parsed.options)
+      return usage_error(@opts) if @opts.is_a?(String)
+
       case @sub
       when "list" then list
       when "stop" then stop(parsed.args)
@@ -121,9 +124,15 @@ module Samagotchi
     def command_name = @sub && SUBCOMMANDS.include?(@sub) ? "chi sessions #{@sub}" : "chi sessions"
     def usage_text = { "stop" => STOP_USAGE, "restart" => RESTART_USAGE, "stats" => STATS_USAGE }.fetch(@sub, USAGE)
 
-    # quirk: a number that isn't one is 0 (--days=abc turns the age limit off)
+    # The options with --days, --keep and --limit as integers, or the usage
+    # error's message for one that isn't a whole number (--days=abc must not
+    # turn the age limit off).
+    # @return [Hash, String]
     def integers(options)
-      options.to_h { |key, value| [key, INTEGER_OPTIONS.include?(key) ? value.to_i : value] }
+      bad = options.find { |key, value| INTEGER_OPTIONS.include?(key) && !value.to_s.match?(/\A-?\d+\z/) }
+      return "--#{bad[0]} takes a whole number, got #{bad[1].to_s.inspect}" if bad
+
+      options.to_h { |key, value| [key, INTEGER_OPTIONS.include?(key) ? Integer(value, 10) : value] }
     end
 
     # The flags a list row carries: a chi scratch session, a test run, an

data/lib/samagotchi/system_prompt.rb

@@ -4,6 +4,7 @@ require_relative "config"
 require_relative "log"
 require_relative "log_path"
 require_relative "memory_paths"
+require_relative "paths"
 require_relative "tool_declarations"
 require_relative "tools/memory"
 require_relative "muted_memories"
@@ -305,10 +306,11 @@ module Samagotchi
     # Ordered for the servers' prompt caches (they reuse only an exact token
     # prefix): what every session shares first, what changes least before
     # what changes more, and the per-session lines last. The global parts
-    # (identity, preloads) come before the project's AGENTS.md, the memory
-    # indexes (a memory write changes them) after both; the model, the
-    # location and the session close the prompt (Gemma's tool declarations
-    # still follow them).
+    # (identity, preloads) come before the project's AGENTS.md, the
+    # toolkit's prompt text after the appended files, the memory indexes (a
+    # memory write changes them) after all of them; the model, the location
+    # and the session close the prompt (Gemma's tool declarations still
+    # follow them).
     def system_prompt_with_index(base, chat: false, thinking: nil, layers: [])
       thinking_token = chat ? "" : Thinking.native(thinking || turn_thinking, profile).system_token
       indexes = { project: read_memory_index("project"), system: read_memory_index("system") }
@@ -318,7 +320,7 @@ module Samagotchi
         "System memories:\n#{indexes[:system]}"
       ].join("\n\n")
       stable = [thinking_token + base, not_loaded_line(layers), rg_guidance, system_identity_section, model_notes_section, explicit_memory_section,
-                project_specific_description, appended_section, memory_sections]
+                project_specific_description, appended_section, kit_prompt_section, memory_sections]
       stable_text = stable.compact.join("\n")
       volatile = [current_model, project_location, current_session].compact
       return with_tail_declarations(stable_text, chat: chat, layers: layers) if volatile.empty?
@@ -359,6 +361,16 @@ module Samagotchi
         "(/toolkit add <name>)."
     end
 
+    # The session's toolkit's prompt text (a kit's prompt:, Toolkit::Kit),
+    # verbatim, after the appended files and before the memory indexes:
+    # sessions on that kit share it, and a memory write doesn't move it.
+    # nil on a kit without one and on full: the prompt is what it was
+    # before kit prompts.
+    def kit_prompt_section
+      registry = @tools_lookup.call
+      registry.respond_to?(:toolkit) ? registry.toolkit&.prompt : nil
+    end
+
     def with_tail_declarations(prompt, chat:, layers:)
       chat || !gemma_tail_declarations? ? prompt : prompt.rstrip + tool_declarations(layers)
     end
@@ -600,19 +612,12 @@ module Samagotchi
       home = Dir.home
       lines << "Home directory: #{home} (write it as ~ or $HOME in commands and paths)" unless home.to_s.empty?
       lines << "Project memories folder (your notes about the project, not its files; never work or run commands there):"
-      lines << home_relative(Tools::MemoryRead.memories_dir("project"))
+      lines << Paths.tilde(Tools::MemoryRead.memories_dir("project"))
       lines.join("\n")
     rescue StandardError
       nil
     end
 
-    def home_relative(path)
-      home = Dir.home
-      path.start_with?("#{home}/") ? "~#{path.delete_prefix(home)}" : path
-    rescue ArgumentError
-      path
-    end
-
     # The model this session runs on. A model guesses its name from
     # training (a fine-tune often knows only its base model's), so the line
     # says to answer from here. It depends only on the effective model, and

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1275,7 +1275,10 @@ module Samagotchi
           elsif %w[model assistant].include?(m[:role].to_s)
             responses = messages.drop(i + 1).take_while { |r| r[:role].to_s == "tool_response" }
             Array(Web::MessageParts.for_message(m, responses)&.dig(:tools)).each do |part|
-              @screen.commit(join_tool_line(part, duration_ms: join_duration(records, part)))
+              record = join_record(records, part)
+              duration = record&.dig("duration_ms")
+              @screen.commit(join_tool_line(part, duration_ms: duration.is_a?(Numeric) ? duration : nil,
+                                                  saved_status: record&.dig("status")))
             end
           end
         end
@@ -1307,28 +1310,36 @@ module Samagotchi
         nil
       end
 
-      # The duration of +part+'s call: the next record of its tool, in call
-      # order, consumed with the ones it skipped. By tool and order, not by
-      # iteration: an empty retry spends an iteration that left no message.
-      # nil (no duration shown) for a call that left none: it never
-      # finished, or a worker before turn ids saved it.
-      def join_duration(records, part)
+      # The saved record of +part+'s call (its duration and status): the
+      # next record of its tool, in call order, consumed with the ones it
+      # skipped. By tool and order, not by iteration: an empty retry spends
+      # an iteration that left no message (as the web's timing.js
+      # takeRecord). nil for a call that left none: it never finished, or a
+      # worker before turn ids saved it.
+      def join_record(records, part)
         return nil if part[:output].nil?
 
         at = records.index { |r| r["tool"].to_s == part[:tool].to_s }
         return nil unless at
 
-        duration = records[at]["duration_ms"]
-        records.shift(at + 1)
-        duration.is_a?(Numeric) ? duration : nil
+        records.shift(at + 1).last
       end
 
       # A saved call's row; "no result" for a call the turn never answered
-      # (it ended first).
-      def join_tool_line(part, duration_ms: nil)
+      # (it ended first). Its status is the saved record's, as live and the
+      # web's reload (a guardrail's "blocked" is no error), else read from
+      # its result.
+      def join_tool_line(part, duration_ms: nil, saved_status: nil)
         output = part[:output]
         command = part.dig(:view, :truncated) ? nil : part.dig(:view, :command)
-        status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool], command: command)
+        status = if output.nil?
+                   "no result"
+                 elsif !saved_status.to_s.empty?
+                   saved_status.to_s
+                 else
+                   ToolActivity.tool_activity_status(ToolActivity.saved_result_text(output), part[:tool],
+                                                     command: command)
+                 end
         activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
                      params: part[:params], status: status,
                      description: ToolView.description_title(part[:view] || {}) }
@@ -1413,7 +1424,8 @@ module Samagotchi
           # hook's notice, a retry's line), as they were drawn live.
           # Questions are left out: the pending one is asked after the
           # replay, answered ones showed no line.
-          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
+          when :turn_started then @renderer.call(without_named_images(event, turn[:prompt]))
+          when :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
             @renderer.call(event)
           end
         end
@@ -1454,7 +1466,16 @@ module Samagotchi
         elsif !(own?(origin[:client_id]) || @shown_enqueued.include?(origin[:enqueued_id]))
           @screen.commit(prompt_line(origin[:client_id], event[:prompt]))
         end
-        @renderer.call(event)
+        # Another client's prompt line is up (here or at its enqueue); an
+        # own send has none, so its image lines are its echo.
+        @renderer.call(own?(origin[:client_id]) ? event : without_named_images(event, event[:prompt]))
+      end
+
+      # The turn's start without its image lines when the prompt line shown
+      # for it is the web's "[image: name]" text of a turn of images alone:
+      # that line names them already.
+      def without_named_images(event, shown_prompt)
+        ImageRef.placeholder_only?(shown_prompt) ? event.except(:images) : event
       end
 
       def complete_turn(event)

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -602,6 +602,10 @@ module Samagotchi
         # The files whose text is in the prompt (SystemPrompt#prompt_files).
         files = prompt_files_text(snapshot[:prompt_files])
         lines << "prompt files:     #{files}" if files
+        # The toolkit's prompt text (Engine#stats_snapshot's kit_prompt).
+        if (kit = snapshot[:kit_prompt])
+          lines << "kit prompt:       #{kit[:kit]} (~#{kit[:tokens]} tokens)"
+        end
         llm_context = llm_context_stats_text(snapshot[:llm_context])
         lines << "llm context:      #{llm_context}" if llm_context
         thinking = setting_stats_text(snapshot[:thinking])