samagotchi 0.64.0 → 0.66.0

data/lib/samagotchi/send_command.rb

@@ -39,7 +39,7 @@ module Samagotchi
 
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [-m TEXT] [--image PATH]...
+             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
@@ -63,8 +63,8 @@ module Samagotchi
                     the current one
         --continues ID
                     (--new) start the next link of that session's chain:
-                    in its folder, on its model, LLM context and
-                    thinking level, with a note carrying its recap; it
+                    in its folder, on its model, LLM context,
+                    thinking level and toolkit, with a note carrying its recap; it
                     is archived. last:ID names the chain's latest link.
                     Without -m the new session waits idle. Refused for a
                     session continued already (naming the next link) or
@@ -77,6 +77,11 @@ module Samagotchi
                     (--new) its own thinking level (off, low, medium,
                     high; default: none of its own), above a process
                     default such as SAMAGOTCHI_THINKING_LEVEL
+        --toolkit NAME, --tool NAME, --no-tool NAME
+                    (--new) its toolkit, the tools its prompts declare
+                    (full, lean, child, a config or bundle one; default
+                    config's toolkit.default), and tools declared on top
+                    of it or left out (repeatable, a comma list too)
         --wait      wait for the answer and print it (one session); the
                     other lines go to stderr. Exit 3: it waits for an
                     answer from you: the question, its options and the
@@ -126,6 +131,9 @@ module Samagotchi
       f.value "--llm-context-apply", key: :llm_apply
       f.value "--llm-context-budget", key: :llm_budget
       f.value "--thinking"
+      f.value "--toolkit"
+      f.value "--tool", key: :tools, repeat: true
+      f.value "--no-tool", key: :no_tools, repeat: true
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
       f.switch "--cut"
@@ -262,7 +270,8 @@ module Samagotchi
       return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
 
-      %i[dir model continues thinking].each { |key| return usage_error("--#{key} needs --new") if options[key] }
+      %i[dir model continues thinking toolkit].each { |key| return usage_error("--#{key} needs --new") if options[key] }
+      TOOLKIT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") unless Array(options[key]).empty? }
       LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
       return usage_error("give session ids") if options[:ids].empty?
 
@@ -273,15 +282,19 @@ module Samagotchi
     LLM_CONTEXT_FLAGS = { llm_strategy: "--llm-context", llm_apply: "--llm-context-apply",
                           llm_budget: "--llm-context-budget" }.freeze
     LLM_CONTEXT_FIELDS = { llm_strategy: :strategy, llm_apply: :apply, llm_budget: :budget_tokens }.freeze
+    # --tool / --no-tool's option keys.
+    TOOLKIT_FLAGS = { tools: "--tool", no_tools: "--no-tool" }.freeze
 
     def new_options(options)
       return usage_error("--new takes no session ids: it starts one session") unless options[:ids].empty?
 
       if options[:continues]
         taken = [("--dir" if options[:dir]), ("--model" if options[:model])] +
-                LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] } + [("--thinking" if options[:thinking])]
+                LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] } + [("--thinking" if options[:thinking])] +
+                [("--toolkit" if options[:toolkit])] + TOOLKIT_FLAGS.filter_map { |key, flag| flag unless Array(options[key]).empty? }
         unless taken.compact.empty?
-          return usage_error("--continues takes the previous session's folder, model, LLM context and thinking level; " \
+          return usage_error("--continues takes the previous session's folder, model, LLM context, thinking level and " \
+                             "toolkit; " \
                              "leave out #{taken.compact.join(", ")}")
         end
       end
@@ -301,6 +314,8 @@ module Samagotchi
 
         options[:thinking] = Thinking.session_level(word)
       end
+      toolkit = Toolkit.from_flags(name: options[:toolkit], add: options[:tools], remove: options[:no_tools])
+      options[:toolkit_value] = toolkit if toolkit
 
       if options[:dir]
         options[:dir] = File.expand_path(options[:dir])
@@ -348,7 +363,8 @@ module Samagotchi
                     SessionManager.spawn_session(**start, working_directory: options[:dir],
                                                           model_name: options[:model],
                                                           setup: SessionSetup.new(llm_context: options[:llm_context],
-                                                                                  thinking: options[:thinking]),
+                                                                                  thinking: options[:thinking],
+                                                                                  toolkit: options[:toolkit_value]),
                                                           state_dir: @state_dir)
                   end
       rescue SessionContinue::Refused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e

data/lib/samagotchi/session.rb

@@ -184,6 +184,19 @@ module Samagotchi
     # couldn't read; nil when there is neither.
     def reasoning_history_file = @reasoning_history&.to_s || @reasoning_history_unread
 
+    # The session's toolkit (Toolkit: the tools its prompts declare), as
+    # given when it was created; nil for a session from before toolkits,
+    # 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).
+    attr_reader :toolkit
+
+    # @param value [Toolkit, Hash, String, nil] the session file's form too
+    def toolkit=(value)
+      @toolkit = value.is_a?(Toolkit) ? value : Toolkit.from_file(value)
+    end
+
     # The hook that stopped the last turn (stop_turn, or a cut with no retry
     # left), e.g. "loop-guard"; nil when it ended otherwise.
     def stopped_by
@@ -213,7 +226,7 @@ module Samagotchi
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
                    continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [],
-                   interrupted_turn: nil)
+                   toolkit: nil, interrupted_turn: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -242,6 +255,7 @@ module Samagotchi
       self.thinking = thinking
       self.reasoning_history = reasoning_history
       self.appended_prompt_files = appended_prompt_files
+      self.toolkit = toolkit
       self.interrupted_turn = interrupted_turn
       @turn_checkpoint = nil
       @archived = false
@@ -336,6 +350,7 @@ module Samagotchi
         thinking: setup.thinking,
         reasoning_history: setup.reasoning_history,
         appended_prompt_files: setup.appended_prompt_files,
+        toolkit: setup.toolkit,
         continues: continues
       )
     end
@@ -400,6 +415,7 @@ module Samagotchi
       "thinking" => nil,
       "reasoning_history" => nil,
       "appended_prompt_files" => [],
+      "toolkit" => nil,
       "interrupted_turn" => nil
     }.freeze
 
@@ -527,6 +543,7 @@ module Samagotchi
                 when "llm_context" then llm_context_file
                 when "thinking" then thinking_file
                 when "reasoning_history" then reasoning_history_file
+                when "toolkit" then @toolkit&.to_file
                 when "prompt_notes" then @prompt_notes.map(&:to_file)
                 when "last_turn" then @last_turn&.to_file
                 when "used_memory_names", "preloaded_memory_names", "muted_memory_names", "appended_prompt_files"
@@ -722,14 +739,15 @@ module Samagotchi
         symbolize_empty_answer(message)
       end
 
-      # An empty-answer note's marker (TurnNote.empty) and its steps, as
-      # they were saved.
+      # An empty-answer note's marker (TurnNote.empty), its steps and its
+      # refusal, as they were saved.
       def symbolize_empty_answer(message)
         marker = message[:empty_answer]
         return message unless marker.is_a?(Hash)
 
         marker = marker.transform_keys(&:to_sym)
         marker[:steps] = marker[:steps].map { |step| step.is_a?(Hash) ? step.transform_keys(&:to_sym) : step } if marker[:steps].is_a?(Array)
+        marker[:refusal] = marker[:refusal].transform_keys(&:to_sym) if marker[:refusal].is_a?(Hash)
         message.merge(empty_answer: marker)
       end
 

data/lib/samagotchi/session_commands.rb

@@ -12,6 +12,7 @@ require_relative "tools/peers"
 require_relative "commands/registry"
 require_relative "llm_context_command"
 require_relative "thinking_command"
+require_relative "toolkit_command"
 require_relative "reasoning_history_command"
 
 module Samagotchi
@@ -32,6 +33,7 @@ module Samagotchi
     HELP_COMMAND = "/help"
     LLM_CONTEXT_COMMAND = LLMContextCommand::NAME
     THINKING_COMMAND = ThinkingCommand::NAME
+    TOOLKIT_COMMAND = ToolkitCommand::NAME
     REASONING_HISTORY_COMMAND = ReasoningHistoryCommand::NAME
     # A remote catalog has hundreds of ids (OpenRouter ~380): plain /models
     # shows this many per host; /models <text> lists every match.
@@ -48,7 +50,7 @@ module Samagotchi
 
     # The commands that ask before a change that restarts the prompt cache
     # (CacheConfirm): #run passes them its confirm flag.
-    CONFIRMING = %i[thinking reasoning_history].freeze
+    CONFIRMING = %i[thinking reasoning_history toolkit].freeze
 
     # @!attribute status [Symbol] :ok, or :error when the line was refused
     # @!attribute output [String, nil] what to tell the user
@@ -103,6 +105,9 @@ module Samagotchi
       registry.register(REASONING_HISTORY_COMMAND, "show or set which of its reasoning this session's model gets back (drop|turn|all|default)",
                         id: :reasoning_history, mid_turn: show_mid_turn(REASONING_HISTORY_COMMAND),
                         match: ->(text) { text.match?(%r{\A/reasoning-history(?:\s+.*)?\z}) }) { |text| reasoning_history(text) }
+      registry.register(TOOLKIT_COMMAND, "show or change the tools this session declares (NAME, add TOOL, remove TOOL)",
+                        id: :toolkit, mid_turn: show_mid_turn(TOOLKIT_COMMAND),
+                        match: ->(text) { text.match?(%r{\A/toolkit(?:\s+.*)?\z}) }) { |text| toolkit(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
@@ -467,6 +472,16 @@ module Samagotchi
       reply(e.message, status: :error)
     end
 
+    # /toolkit (ToolkitCommand); :toolkit in changed when it set the
+    # session's toolkit.
+    def toolkit(text, confirm: true)
+      output, changed, ask = ToolkitCommand.new(engine: @engine, save: ->(session) { save_setup(session) })
+                                           .run(text.delete_prefix(TOOLKIT_COMMAND), confirm: confirm)
+      reply(output, changed: changed ? [:toolkit] : [], confirm: ask)
+    rescue ArgumentError => e
+      reply(e.message, status: :error)
+    end
+
     # A session setting changed (/llm-context, /thinking, /reasoning-history):
     # saved with its model.
     def save_setup(session)

data/lib/samagotchi/session_manager.rb

@@ -140,7 +140,9 @@ 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)
+    #   --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)
     # @param continues [String, nil] the session this one continues (a
     #   session field; SessionContinue)
     # @param note [String, nil] a context note the session starts with,
@@ -177,6 +179,7 @@ module Samagotchi
         setup: setup,
         continues: continues
       )
+      session.toolkit = Toolkit.configured(delegate: delegate) if delegate || 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.

data/lib/samagotchi/session_metrics.rb

@@ -883,7 +883,7 @@ module Samagotchi
       payload = event[:payload]
       payload = {} unless payload.is_a?(Hash)
 
-      @mutex.synchronize { note_first_chunk(payload, event) }
+      @mutex.synchronize { note_first_chunk(event) }
       usage = TokenUsage.from_payload(payload)
       if usage
         @mutex.synchronize { note_server_usage(usage) if @turn }
@@ -915,21 +915,16 @@ module Samagotchi
       turn.gen_had_server = true
     end
 
-    # The first chunk with content, reasoning or a tool call starts the
-    # generation's decode clock (an estimated speed runs from it). Caller
-    # holds the mutex.
-    def note_first_chunk(payload, event)
+    # The first chunk with content, reasoning or a tool call (the loop marks
+    # its event tool_call: true, whatever the wire) starts the generation's
+    # decode clock (an estimated speed runs from it). Caller holds the mutex.
+    def note_first_chunk(event)
       return unless @turn && @turn.gen_open && @turn.gen_first_chunk_at.nil?
-      return unless !event[:content].to_s.empty? || tool_call_delta?(payload)
+      return unless !event[:content].to_s.empty? || event[:tool_call]
 
       @turn.gen_first_chunk_at = monotonic_time
     end
 
-    def tool_call_delta?(payload)
-      choice = payload["choices"].is_a?(Array) ? payload["choices"].first : nil
-      choice.is_a?(Hash) && choice["delta"].is_a?(Hash) && !Array(choice["delta"]["tool_calls"]).empty?
-    end
-
     def event_content_chars(payload, event)
       len = payload_content(payload, event).length
       len.positive? ? len : nil

data/lib/samagotchi/session_setup.rb

@@ -3,6 +3,7 @@
 require_relative "llm_context_override"
 require_relative "reasoning_history"
 require_relative "thinking"
+require_relative "toolkit"
 
 module Samagotchi
   # A session's own settings that come before its model's, carried as one
@@ -12,27 +13,33 @@ module Samagotchi
   # +thinking+ a level Symbol (Thinking.session_level) or nil,
   # +reasoning_history+ a level Symbol (ReasoningHistory.session_level) or nil,
   # +appended_prompt_files+ the absolute paths chi --append-system-prompt
-  # named (their text goes into the system prompt; [] with none).
+  # named (their text goes into the system prompt; [] with none),
+  # +toolkit+ a Toolkit or nil (SessionManager.spawn_session gives the
+  # session config's toolkit.default then).
   #
   # 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).
-  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files) do
-    def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [])
+  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,
-            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze)
+            appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit)
     end
 
-    def empty? = llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty?
+    def empty?
+      llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil?
+    end
 
-    # A session's own setup, for a session that starts from it.
+    # A session's own setup, for a session that starts from it. Its
+    # toolkit always: one from before toolkits is full (Toolkit.of), not
+    # whatever config's default is now.
     # @param session [Session, nil]
     # @return [SessionSetup]
     def self.of(session)
       return new if session.nil?
 
       new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
-          appended_prompt_files: session.appended_prompt_files)
+          appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit))
     end
   end
 end

data/lib/samagotchi/steer_cut.rb

@@ -82,6 +82,10 @@ module Samagotchi
       @waiting.epoch
     end
 
+    # The running generation's phase (GenerationPhase::Snapshot), nil with
+    # none running.
+    def generation_snapshot = @phase.snapshot
+
     # The turn's stream: the generation's phase follows it, and a thinking
     # chunk rechecks a waiting message. +progress+: a chunk's lanes
     # (.lanes), read from it when not given.

data/lib/samagotchi/system_prompt.rb

@@ -317,7 +317,7 @@ module Samagotchi
         "Project memories:\n#{indexes[:project]}",
         "System memories:\n#{indexes[:system]}"
       ].join("\n\n")
-      stable = [thinking_token + base, rg_guidance, system_identity_section, model_notes_section, explicit_memory_section,
+      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]
       stable_text = stable.compact.join("\n")
       volatile = [current_model, project_location, current_session].compact
@@ -328,6 +328,21 @@ module Samagotchi
       with_tail_declarations(prompt, chat: chat, layers: layers)
     end
 
+    # 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.
+    def not_loaded_line(layers)
+      registry = @tools_lookup.call
+      return nil unless registry.respond_to?(:left_out_names)
+
+      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>)."
+    end
+
     def with_tail_declarations(prompt, chat:, layers:)
       chat || !gemma_tail_declarations? ? prompt : prompt.rstrip + tool_declarations(layers)
     end

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -46,17 +46,23 @@ module Samagotchi
       # @param thinking [String, nil] --thinking as typed: a new session
       #   starts with it as its own level; a resumed or attached one's
       #   worker gets a /thinking, after those
+      # @param toolkit [Toolkit, nil] --toolkit/--tool/--no-tool: a new
+      #   session's toolkit (config's toolkit.default without); an existing
+      #   session keeps its own
+      # @param toolkit_flags [Array<String>] which of those were given, for
+      #   the line an existing session's run prints
       # @param state_dir [String, nil] where the sessions are (the default
       #   state dir by default): the worker's, for the attached loop too
       # @return [Symbol] :detached, :closed when the worker went away,
       #   :failed when the --model switch didn't go through, or (input from a
       #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
-              memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], state_dir: nil)
+              memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
+              toolkit_flags: [], state_dir: nil)
         state_dir ||= Session.default_state_dir
         client = connect(attach: attach, shared: shared, resume: resume, model: model, state_dir: state_dir,
                          memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking,
-                         appended_prompt_files: appended_prompt_files)
+                         appended_prompt_files: appended_prompt_files, toolkit: toolkit, toolkit_flags: toolkit_flags)
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
@@ -123,10 +129,12 @@ module Samagotchi
       # @return [BridgeClient] a client for the live Bridge of the session
       # @raise [Error]
       def connect(attach: nil, shared: false, resume: nil, model: nil, state_dir: nil, wait: BRIDGE_WAIT,
-                  memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], err: $stderr)
+                  memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
+                  toolkit_flags: [], err: $stderr)
         sd = state_dir || Session.default_state_dir
         if attach || resume
-          warn_memory_flags_ignored(attach || resume, memories, muted_memories, err, appended_prompt_files: appended_prompt_files)
+          warn_memory_flags_ignored(attach || resume, memories, muted_memories, err, appended_prompt_files: appended_prompt_files,
+                                                                                     toolkit_flags: toolkit_flags)
         end
         if attach
           live = connect_existing(attach, sd)
@@ -143,7 +151,8 @@ module Samagotchi
                                                  memories: memories, muted_memories: muted_memories,
                                                  setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
                                                                          thinking: Thinking.session_level(thinking),
-                                                                         appended_prompt_files: appended_prompt_files))
+                                                                         appended_prompt_files: appended_prompt_files,
+                                                                         toolkit: toolkit))
                   end
         client = BridgeClient.wait_for(session.id, session_dir: Session.session_dir(session.id, state_dir: sd), timeout: wait)
         client || raise(Error, "the worker for session #{session.id} did not start its Bridge in time")
@@ -159,14 +168,15 @@ module Samagotchi
       end
 
       # An existing session's prompt is built from its own session fields:
-      # --memory/--mute/--append-system-prompt given with --attach or
-      # --resume are ignored, with a line saying so (printed before the live
-      # region opens).
-      def warn_memory_flags_ignored(session_id, memories, muted_memories, err, appended_prompt_files: [])
+      # --memory/--mute/--append-system-prompt and the toolkit flags given
+      # with --attach or --resume are ignored, with a line saying so (printed
+      # before the live region opens).
+      def warn_memory_flags_ignored(session_id, memories, muted_memories, err, appended_prompt_files: [], toolkit_flags: [])
         flags = []
         flags << "--memory" unless Array(memories).empty?
         flags << "--mute" unless Array(muted_memories).empty?
         flags << "--append-system-prompt" unless Array(appended_prompt_files).empty?
+        flags.concat(toolkit_flags)
         return if flags.empty?
 
         verb = flags.size == 1 ? "applies" : "apply"

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -260,13 +260,17 @@ module Samagotchi
           take_session_state(event[:session_state_snapshot] || {})
           return render_snapshot(event[:snapshot] || {}, reset: event[:type] == :reset)
         when :turn_enqueued then show_enqueued(event)
-        when :turn_started then start_turn(event)
+        when :turn_started
+          @status.take_event(event)
+          start_turn(event)
         when :turn_completed
+          @status.take_event(event)
           complete_turn(event)
           refresh_children
           own_turn_ended(event)
         # The renderer says how it ended (the REPL's words too).
         when :turn_canceled, :turn_failed
+          @status.take_event(event)
           @renderer.call(event)
           end_turn
           refresh_children
@@ -1239,7 +1243,7 @@ module Samagotchi
         # A turn that ended with no answer: its notice, as live.
         empty = messages.drop(from + 1).filter_map { |m| TurnNote.empty_answer(m) }.last
         if empty
-          @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"]))
+          @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"], empty[:refusal] || empty["refusal"]))
         elsif failed
           # A failed turn whose steps stayed: the line the live view left,
           # and no step text as if it were the answer (the web keeps a
@@ -1379,6 +1383,8 @@ module Samagotchi
       def render_current_turn(turn)
         @running = !turn.nil?
         @joined_mid_turn = @running
+        # A turn running at the join: the status row's steer hint.
+        @status.update(running: @running)
         return unless turn
 
         continues = turn[:prompt].nil?

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -179,7 +179,8 @@ module Samagotchi
         end
         # No answer: chi's muted notice, never an empty answer line.
         if summary[:empty_answer]
-          @view.print_line(@view.format_empty_answer_line(summary.dig(:empty_answer, :retries)))
+          empty = summary[:empty_answer]
+          @view.print_line(@view.format_empty_answer_line(empty[:retries], empty[:refusal]))
         else
           @view.print_line(summary[:output])
         end

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -135,9 +135,10 @@ module Samagotchi
       end
 
       # "no answer: the model returned nothing (after 1 retry)", dim like the
-      # retry row: a turn that ended with no answer (TurnNote.empty_answer_line).
-      def format_empty_answer_line(retries)
-        paint(TurnNote.empty_answer_line(retries), 90)
+      # retry row: a turn that ended with no answer, or "no answer: refused
+      # by the provider (cyber)" for a +refusal+ (TurnNote.empty_answer_line).
+      def format_empty_answer_line(retries, refusal = nil)
+        paint(TurnNote.empty_answer_line(retries, refusal: refusal), 90)
       end
 
       # "↻ retrying (503) in 4.0s, 2/5": the live status while the provider

data/lib/samagotchi/terminal_ui/status_row.rb

@@ -28,7 +28,15 @@ module Samagotchi
       #   preloaded             its --memory list (shown until a turn
       #                         records them as used)
       #   muted                 its --mute list
-      FIELDS = %i[model default_model served parent_id children context used_memories preloaded muted].freeze
+      #   running               a turn runs: the row trails STEER_HINT
+      FIELDS = %i[model default_model served parent_id children context used_memories preloaded muted running].freeze
+
+      # The tail while a turn runs: where a typed line goes (the next step)
+      # and the two other choices. Dropped whole first when the row is cut.
+      STEER_HINT = " · typing goes in at the next step (/cut, /queue)"
+
+      # The turn events that end a turn (the hint goes).
+      TURN_END_EVENTS = %i[turn_completed turn_canceled turn_failed].freeze
 
       # @param surface [Surface] with #columns
       def initialize(surface)
@@ -77,13 +85,16 @@ module Samagotchi
 
       # Take what a turn event says about the row (the Engine's events in
       # the REPL, the Bridge's in attached mode): ctx, the memories used,
-      # the model the server served. Other events change nothing.
+      # the model the server served, whether a turn runs (the steer
+      # hint). Other events change nothing.
       def take_event(event)
         case event[:type]
         when :context_status then update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
         when :used_memories_updated then update(used_memories: Array(event[:used_memory_names]))
         when :generation_completed
           update(served: [event[:served_model], event[:requested_model], event[:served_expected_by]]) if event[:served_model]
+        when :turn_started then update(running: true)
+        when *TURN_END_EVENTS then update(running: false)
         end
       end
 
@@ -119,11 +130,21 @@ module Samagotchi
                     status_context_text(estimate: @values[:context]),
                     status_memory_text(Array(@values[:used_memories]) | Array(@values[:preloaded]), MEMORY_LIMIT),
                     status_memory_text(@values[:muted], MEMORY_LIMIT, label: "muted")].reject(&:empty?)
-        status_rows(segments, width)
+        status_rows(with_steer_hint(segments, width), width)
       end
 
       private
 
+      # +segments+ with STEER_HINT after the last while a turn runs, when
+      # the whole row fits +width+ with it: on a narrow terminal the hint
+      # goes first, whole, before anything else is cut.
+      def with_steer_hint(segments, width)
+        return segments unless @values[:running] && segments.any?
+        return segments if "status> #{segments.join(" | ")}#{STEER_HINT}".length > width
+
+        segments[0..-2] + ["#{segments.last}#{STEER_HINT}"]
+      end
+
       # `⑂ 2 running · 1 waiting`, the counts there are; "" with neither (no
       # children, or all ended). Not "not reported": a REPL parent is never
       # given its children's replies (no wakes there), and a worker moves

data/lib/samagotchi/terminal_ui.rb

@@ -97,10 +97,15 @@ module Samagotchi
     # @param appended_prompt_files [Array<String>] --append-system-prompt's
     #   files (absolute): a new session saves them; a resumed one's own come
     #   first, and the merge goes only to the Engine (as --memory's does)
+    # @param toolkit [Toolkit, nil] --toolkit/--tool/--no-tool: a new
+    #   session's toolkit (config's toolkit.default without); a resumed one
+    #   keeps its own, with a line naming +toolkit_flags+ (the flags given)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
                    spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
-                   appended_prompt_files: [])
+                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [])
       @scratch        = scratch
+      @toolkit        = toolkit
+      @toolkit_flags  = toolkit_flags
       @thinking_word  = thinking
       @prompt         = prompt
       @llm_context_words = llm_context
@@ -269,7 +274,7 @@ module Samagotchi
         preloaded_memory_names: @requested_memories,
         muted_memory_names: @muted_memory_names,
         scratch: @scratch,
-        setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files)
+        setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured)
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.
@@ -279,6 +284,7 @@ module Samagotchi
         session.thinking = Thinking.session_level(@thinking_word) if @thinking_word
         session.save if @resume_session
       end
+      warn_toolkit_flags_ignored(session) if @resume_session
       claim_session!(session.id) unless @owner_lock
       # A turn a worker died in (TurnCheckpoint): ended as canceled, with its
       # note, before this REPL's first turn appends after it.
@@ -714,6 +720,16 @@ module Samagotchi
       end
     end
 
+    # The toolkit flags are a new session's: a resumed one keeps its own
+    # toolkit (as attached mode says it, AttachLauncher).
+    def warn_toolkit_flags_ignored(session)
+      return if @toolkit_flags.empty?
+
+      names = @toolkit_flags.size > 1 ? "#{@toolkit_flags[0..-2].join(", ")} and #{@toolkit_flags.last}" : @toolkit_flags.first
+      warn "(#{names} #{@toolkit_flags.size == 1 ? "applies" : "apply"} to a new session; #{session.id}'s prompt is already built)"
+    end
+    private :warn_toolkit_flags_ignored
+
     private
 
     # Interactive REPL loop. Session seed + messages are built by #run and

data/lib/samagotchi/tool_runner.rb

@@ -49,8 +49,11 @@ module Samagotchi
     def run(call, iteration:, call_index:, call_count:, on_stream_event:, max_tool_output_chars:)
       params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
       # The gate runs first, so tool_call_started shows the call that runs.
+      # A tool the session's toolkit leaves out skips it: no before_tool_call
+      # hook, no approval card for a call that can't run (KernelLoop#dispatch
+      # answers it with the not-loaded error).
       original = call.dup
-      verdict = evaluate(call, iteration, params)
+      verdict = left_out?(call) ? Guardrails::Verdict.new(call: call) : evaluate(call, iteration, params)
       call = verdict.call
       params = ToolActivity.tool_activity_params(call[:name], call, registry: tools)
       label = plugin_label(call[:name])
@@ -265,6 +268,15 @@ module Samagotchi
     # The kernel's tools, for the activity line of a tool that isn't built in.
     def tools = @kernel.tools
 
+    # A real tool the session's toolkit leaves out of this turn.
+    def left_out?(call)
+      registry = tools
+      return false unless registry.respond_to?(:left_out) && !call[:name].nil?
+
+      layers = @kernel.respond_to?(:llm_context_layers) ? @kernel.llm_context_layers : []
+      !registry.left_out(call[:name], layers: layers).nil?
+    end
+
     # A tool the registry has from a plugin (not core, not unknown).
     def plugin_tool?(name)
       entry = tools && !name.nil? ? tools[name] : nil