samagotchi 0.70.0 → 0.72.0

data/lib/samagotchi/tool_activity.rb

@@ -35,6 +35,14 @@ module Samagotchi
 
     module_function
 
+    # A saved tool output's leading "ran as: …" line (ToolRunner#changed_call_line) and "[tool]" lead (the
+    # shape of ToolResponse::LEAD), which the live status never sees: it reads the tool's own result.
+    SAVED_LEAD = /\A(?:ran as: [^\n]*\n)?\[[^\]\s]+\](?:\n| |\z)/
+
+    # A saved output (what the model got) as the tool's own text, for tool_activity_status.
+    # Without a "[tool]" lead (an older or hand-made output) it stays as it is.
+    def saved_result_text(output) = output.to_s.sub(SAVED_LEAD, "")
+
     # @param registry [Tools::Registry, nil] the session's tools
     # @param cwd [String, nil] what a file tool's title is relative to (the
     #   worker runs in its session's working directory)
@@ -211,12 +219,16 @@ module Samagotchi
     # exited non-zero (its last "exit: N" line; no number: killed by a
     # signal), so the turn tally's "(N failed)" counts it; but not a grep
     # that found nothing (no_match?, given the +command+): that stays "ok".
+    # Also for a task_wait whose task failed (exited non-zero or without an
+    # exit code): its header's status, never a line of the log's tail.
     # "stopped" for a
     # task_wait the user's Stop ended (the task itself runs on), for one
     # whose task was stopped (the stop-task button, or the model's task_stop),
     # and for a command the user's Stop (or a signal to chi, a session stop)
     # killed or kept from starting: a cancel, not a failure (its text still
     # starts "Error:" for the model).
+    # A task_wait's own outcome is read from its header alone: the log's tail
+    # can print any line, "status: stopped" included.
     def tool_activity_status(result, tool_name = nil, command: nil)
       text = result.to_s
       return "stopped" if [Tools::Execute::NOT_RUN_ON_STOP, *Tools::Execute::NOT_RUN.values].include?(text)
@@ -230,7 +242,13 @@ module Samagotchi
       if tool_name == Tools::Execute::NAME && execute_failed?(text)
         return no_match?(text, command) ? "ok" : "error"
       end
-      return "stopped" if tool_name == Tools::TaskWait::NAME && text.match?(/^(wait_result: canceled|status: stopped)$/)
+
+      if tool_name == Tools::TaskWait::NAME
+        # The header: every line before the log's tail (output_tail:), which can print any line.
+        header = text.split(/^output_tail:$/, 2).first.to_s
+        return "stopped" if header.match?(/^(wait_result: canceled|status: stopped)$/)
+        return "error" if header[/^status: (\S+)$/, 1] == "failed"
+      end
 
       "ok"
     end
@@ -387,6 +405,7 @@ module Samagotchi
         parts = []
         parts << "session=#{preview_tool_param(call[:session])}" unless call[:session].to_s.strip.empty?
         parts << "model=#{preview_tool_param(call[:model])}" unless call[:model].to_s.strip.empty?
+        parts << "toolkit=#{preview_tool_param(call[:toolkit])}" unless call[:toolkit].to_s.strip.empty?
         parts << "task=#{preview_tool_param(call[:content])}"
         parts << "wait=#{preview_tool_param(call[:wait])}" unless call[:wait].nil? || call[:wait].to_s.strip.empty?
         parts.join(" ")

data/lib/samagotchi/tool_declarations.rb

@@ -377,6 +377,10 @@ module Samagotchi
               type: "string",
               description: "The new child's working folder: a worktree or subfolder of this session's repository (create a worktree with execute `git worktree add ../<repo>-<name> -b <branch>` first). Default: this session's folder"
             },
+            toolkit: {
+              type: "string",
+              description: "The new child's toolkit, by name (default: the configured child toolkit); not with session"
+            },
             wait: {
               type: "boolean",
               description: "true (default): this call waits for the reply; pick it only when this turn needs the reply to go on. false: returns at once and the reply comes later as a delegate report (also when you are idle); pick it for work that takes minutes, several children side by side, or to keep talking with your user"

data/lib/samagotchi/tool_output_cut.rb

@@ -37,6 +37,12 @@ module Samagotchi
     # partial read by it. Kept in sync with head_line by its spec.
     HEAD_CUT = /\[cut: \d+ of \d+ chars; read it in parts\]\z/
 
+    # What a web row keeps of a tool's output, on a reload
+    # (Web::MessageParts) and a mid-turn join (Bridge::TurnAccumulator): the
+    # row shows 300 chars and the rest on hover. A longer one keeps its head
+    # and tail (preview).
+    WEB_PREVIEW_CHARS = 2000
+
     # The head's chars at most (execute.cut_head_chars): never more than a
     # quarter of the room; the tail gets the rest.
     HEAD_CHARS = 1000
@@ -55,10 +61,13 @@ module Samagotchi
     PREVIEW_MARK = "[TRUNCATED_PREVIEW_HEAD]"
     # execute's blocks (Tools::Execute#call): stdout, stderr, then the exit
     # line last (a hint in brackets may follow it). A killed or handed-over
-    # command has none: its output isn't all there is.
+    # command has none: its output isn't all there is. A command a signal
+    # ended (a segfault, an OOM kill) has an exit line with no number
+    # ("exit: "): it ended, so its output is all there is. The JS twin is
+    # turn_html.js's EXIT_LINE.
     STDOUT_LABEL = "\nstdout:\n"
     STDERR_LABEL = "\nstderr:\n"
-    EXIT_LINE = /\nexit: -?\d+[^\n]*(?:\n\([^\n]*\))?\z/
+    EXIT_LINE = /\nexit: (?:-?\d+)?[^\n]*(?:\n\([^\n]*\))?\z/
 
     # The share of the room stdout gets when both blocks are cut.
     STDOUT_SHARE = Rational(2, 3)

data/lib/samagotchi/toolkit.rb

@@ -78,21 +78,25 @@ module Samagotchi
       end
 
       # What the prompt carries of it: the declared names, the reachable
-      # and removed ones (the not-loaded line, find_tools' chi line) and,
-      # when either list has any, the kit name the line gives. Two equal
-      # keys build the same prompt (/toolkit's "no change", its cost).
+      # and removed ones (the not-loaded line, find_tools' chi line), when
+      # either list has any the kit name the line gives, and the kit's
+      # prompt text. Two equal keys build the same prompt (/toolkit's "no
+      # change", its cost).
       def prompt_key
-        [declared.map(&:name), reachable, removed, reachable.empty? && removed.empty? ? nil : resolved.name]
+        [declared.map(&:name), reachable, removed, reachable.empty? && removed.empty? ? nil : resolved.name,
+         resolved.prompt]
       end
 
       # What the UIs show (the snapshot, command_ran): nil when it declares
       # every tool on full (full, full +delegate), which has no chip.
-      # +left_out+ is +reachable+ and +removed+ together.
+      # +left_out+ is +reachable+ and +removed+ together; +prompt+ (the
+      # kit's text) only when the kit has one.
       def summary
         return nil if toolkit.name == Toolkit::FULL && left_out.empty? && resolved.fallback.nil?
 
-        { name: toolkit.name, label: toolkit.label, left_out: left_out, reachable: reachable, removed: removed,
-          fallback: resolved.fallback }
+        summary = { name: toolkit.name, label: toolkit.label, left_out: left_out, reachable: reachable,
+                    removed: removed, fallback: resolved.fallback }
+        resolved.prompt ? summary.merge(prompt: resolved.prompt) : summary
       end
     end
 
@@ -102,14 +106,30 @@ module Samagotchi
     # A named list of declared tools: +tools+ (:all, every built-in; or the
     # built-in names) when it has no +base+, else its +base+'s with +add+
     # and +remove+. +source+: "core", "config", or the bundle that declared
-    # it (chi.toolkit).
-    Kit = Data.define(:name, :base, :tools, :add, :remove, :source) do
-      def initialize(name:, base: nil, tools: nil, add: [], remove: [], source: "core")
+    # it (chi.toolkit). +prompt+: text the sessions on it get in their
+    # system prompt, verbatim (stripped); nil inherits the base's, "" clears
+    # it.
+    Kit = Data.define(:name, :base, :tools, :add, :remove, :source, :prompt) do
+      def initialize(name:, base: nil, tools: nil, add: [], remove: [], source: "core", prompt: nil)
         super(name: name.to_s, base: base&.to_s, tools: tools == :all ? :all : Toolkit.tool_names(tools),
-              add: Toolkit.tool_names(add), remove: Toolkit.tool_names(remove), source: source.to_s)
+              add: Toolkit.tool_names(add), remove: Toolkit.tool_names(remove), source: source.to_s,
+              prompt: prompt.is_a?(String) ? prompt.strip.freeze : nil)
       end
     end
 
+    # The longest kit prompt, in characters: it is a cached prefix, not a
+    # document (long text belongs in append_system_prompt:).
+    PROMPT_MAX = 2000
+
+    # Why +value+ can't be a kit's prompt (text, at most PROMPT_MAX
+    # characters once stripped), nil when it can (nil too: no prompt).
+    def self.prompt_error(value)
+      return nil if value.nil?
+      return "prompt must be text" unless value.is_a?(String)
+
+      "prompt is over #{PROMPT_MAX} characters" if value.strip.length > PROMPT_MAX
+    end
+
     # The built-ins `lean` declares: the file and shell tools, memories,
     # the task tools (execute's hand-over, turn notes and task_wait's tail
     # name the trio), questions, web_fetch, and context_read (core notes
@@ -133,14 +153,17 @@ module Samagotchi
     # an LLM context layer gates (forget_outputs), but for +removed+;
     # +added+ declares any registered tool. +fallback+: why the session's
     # own toolkit couldn't be resolved (this is FULL then), nil when it was.
-    Resolved = Data.define(:name, :all_core, :core, :added, :removed, :fallback) do
-      def initialize(name:, all_core: false, core: [], added: [], removed: [], fallback: nil)
+    # +prompt+: the kit's prompt text (its own or its base's), nil without.
+    Resolved = Data.define(:name, :all_core, :core, :added, :removed, :fallback, :prompt) do
+      def initialize(name:, all_core: false, core: [], added: [], removed: [], fallback: nil, prompt: nil)
         super(name: name.to_s, all_core: all_core, core: core.dup.freeze, added: added.dup.freeze,
-              removed: removed.dup.freeze, fallback: fallback)
+              removed: removed.dup.freeze, fallback: fallback, prompt: prompt)
       end
 
-      # Every built-in and nothing removed: what no toolkit declares.
-      def everything? = all_core && removed.empty?
+      # Every built-in, nothing removed and no prompt text: what no toolkit
+      # declares (the Registry's nil). A kit on full's tools with a prompt
+      # is kept, so its text reaches the system prompt.
+      def everything? = all_core && removed.empty? && prompt.nil?
 
       # @param entry [Tools::Registry::Entry]
       def declares?(entry)
@@ -216,7 +239,8 @@ module Samagotchi
     # @param after [Object] what it would carry after the change
     def self.cache_cost(before, after) = before == after ? nil : :full
 
-    # @return [Resolved] +name+'s kit through its bases
+    # @return [Resolved] +name+'s kit through its bases; its prompt is the
+    #   kit's own, else its base's ("" clears it: nil)
     # @raise [Unresolved] unknown, or a cycle
     def self.resolve_kit(name, kits, seen = [])
       raise Unresolved, "no toolkit named #{name}" unless (kit = kits[name])
@@ -227,16 +251,23 @@ module Samagotchi
              else
                Resolved.new(name: name, all_core: kit.tools == :all, core: kit.tools == :all ? [] : kit.tools)
              end
-      base.changed(add: kit.add, remove: kit.remove).with(name: name)
+      prompt = kit.prompt.nil? ? base.prompt : kit.prompt
+      base.changed(add: kit.add, remove: kit.remove).with(name: name, prompt: prompt.to_s.empty? ? nil : prompt)
     end
 
+    # The keys a config kit entry takes.
+    KIT_KEYS = %w[base add remove prompt].freeze
+
     # The kits known: the built-ins, then config's toolkit.kits, then the
     # plugins' (chi.toolkit). A config kit with a built-in's name is left
     # out (one it can't redefine) with a line in +errors+, and so is one
-    # that isn't a {base:, add:, remove:} map.
+    # that isn't a {base:, add:, remove:, prompt:} map. One with another key
+    # (a typo, a tools: list) still loads, with a line naming the key, and
+    # so does one whose prompt isn't text or is over PROMPT_MAX characters:
+    # without the prompt, with a line saying why.
     # @param config [Hash, nil] toolkit.kits
     # @param plugins [Array<Kit>]
-    # @param errors [Array<String>] gets a line per kit left out
+    # @param errors [Array<String>] gets a line per kit left out or unknown key
     # @return [Hash{String => Kit}]
     def self.kits(config: nil, plugins: [], errors: [])
       kits = BUILTIN_KITS.dup
@@ -245,11 +276,18 @@ module Samagotchi
         if kits.key?(name)
           errors << "toolkit.kits.#{name}: #{name} is a built-in toolkit"
         elsif !spec.is_a?(Hash)
-          errors << "toolkit.kits.#{name}: expected {base:, add:, remove:}"
+          errors << "toolkit.kits.#{name}: expected {base:, add:, remove:, prompt:}"
         else
           spec = spec.transform_keys(&:to_s)
+          (spec.keys - KIT_KEYS).each do |key|
+            errors << "toolkit.kits.#{name}: unknown key #{key} (a kit takes base:, add:, remove:, prompt:)"
+          end
+          if (problem = prompt_error(spec["prompt"]))
+            errors << "toolkit.kits.#{name}: #{problem}; the kit loads without it"
+            spec.delete("prompt")
+          end
           kits[name] = Kit.new(name: name, base: spec["base"] || FULL, add: spec["add"], remove: spec["remove"],
-                               source: "config")
+                               prompt: spec["prompt"], source: "config")
         end
       end
       plugins.each { |kit| kits[kit.name] ||= kit }

data/lib/samagotchi/toolkit_binding.rb

@@ -51,7 +51,9 @@ module Samagotchi
     end
 
     # The session's toolkit resolved (Toolkit::Resolved): what its next
-    # turn declares. A plain full toolkit is nil, the Registry's "every tool".
+    # turn declares. A plain full toolkit is nil, the Registry's "every
+    # tool"; a kit on full's tools with a prompt text is not (its text
+    # reaches the prompt).
     def resolved(session, errors = [])
       resolved = Toolkit.of(session&.toolkit).resolve(kits(errors))
       resolved.everything? ? nil : resolved
@@ -106,10 +108,10 @@ module Samagotchi
 
     # Resolve the session's toolkit into the Registry, on the turn thread at
     # a turn's start (before its prompt is built), and build the prompts
-    # again when what it declares changed. A name that doesn't resolve (a
-    # typo, an uninstalled bundle) declares everything for now and says so
-    # once; the saved toolkit stays as it is.
-    # @return [Boolean] whether the declared tools changed
+    # again when what it declares (or its kit's prompt text) changed. A
+    # name that doesn't resolve (a typo, an uninstalled bundle) declares
+    # everything for now and says so once; the saved toolkit stays as it is.
+    # @return [Boolean] whether the declared tools (or the kit's prompt text) changed
     def apply!(session, on_event = nil)
       errors = []
       resolved = Toolkit.of(session&.toolkit).resolve(kits(errors))

data/lib/samagotchi/toolkit_command.rb

@@ -49,8 +49,7 @@ module Samagotchi
       cost = Toolkit.cache_cost(before.prompt_key, after.prompt_key)
       if confirm && !yes && CacheConfirm.needed?(cost: cost, history: @engine.history?, changed: !cost.nil?)
         step = CacheConfirm.confirm(NAME, words)
-        return [[change_line(before, after), "The tools are the front of every request: the whole prompt is read " \
-                                             "again from them on.", step.text].join("\n"), false, step]
+        return [[change_line(before, after), reread_line(before, after), step.text].join("\n"), false, step]
       end
 
       session.toolkit = after.toolkit
@@ -58,9 +57,10 @@ module Samagotchi
       [[listing(after), "From the next turn's start (a running turn keeps its tools)."].join("\n"), true, nil]
     end
 
-    # The toolkit, its declared tools with tokens, and the ones left out:
-    # reachable with find_tools / call_tool, removed (only /toolkit add
-    # brings one back), or, with call_tool not declared, not loaded.
+    # The toolkit, its declared tools with tokens, its kit's prompt text
+    # (when it has one), and the ones left out: reachable with find_tools /
+    # call_tool, removed (only /toolkit add brings one back), or, with
+    # call_tool not declared, not loaded.
     def listing(explained)
       toolkit = explained.toolkit
       lines = ["toolkit: #{toolkit.label}#{" (applies at the next turn's start)" if explained.pending}"]
@@ -70,6 +70,7 @@ module Samagotchi
       declared = explained.declared
       lines << "  declared (#{declared.size}, ~#{format_tokens(declared.sum { |entry| tokens(entry) })} tokens): " \
                "#{declared.map { |entry| "#{entry.name} ~#{format_tokens(tokens(entry))}" }.join(", ")}"
+      lines << prompt_line(explained.resolved.prompt) if explained.resolved.prompt
       left_out = explained.left_out
       if explained.reachable.empty?
         lines << "  not loaded: #{left_out.empty? ? "none" : left_out.join(", ")}"
@@ -119,12 +120,34 @@ module Samagotchi
       parts << "leaves out #{left.join(", ")}" unless left.empty?
       parts << "removes #{hard.join(", ")} (call_tool can't reach #{hard.size == 1 ? "it" : "them"})" unless hard.empty?
       parts << "lets call_tool reach #{soft.join(", ")}" unless soft.empty?
+      # The kit's prompt text (Toolkit::Kit#prompt) is in the prompt too.
+      text = after.resolved.prompt
+      parts << (text ? "sends its kit's prompt text" : "drops the kit's prompt text") if text != before.resolved.prompt
       parts << "declares the same tools under its own name" if parts.empty?
       "Switching to #{after.toolkit.label} #{parts.join("; ")}."
     end
 
+    # What the confirm says is read again: from the tools on (the front of
+    # every request), or from the kit's prompt text on when only that
+    # changes (Explained#prompt_key's last part: a kit on full's tools).
+    def reread_line(before, after)
+      if before.prompt_key[0...-1] == after.prompt_key[0...-1]
+        "The kit's prompt text is in the system prompt: the prompt is read again from it on."
+      else
+        "The tools are the front of every request: the whole prompt is read again from them on."
+      end
+    end
+
     def names(explained) = explained.declared.map(&:name)
 
+    # The kit's prompt text (Toolkit::Kit#prompt): its first line, how many
+    # more and its estimated tokens.
+    def prompt_line(text)
+      first, *rest = text.lines.map(&:chomp)
+      more = rest.empty? ? "" : "+#{rest.size} line#{"s" if rest.size > 1}, "
+      "  prompt: #{first} (#{more}~#{format_tokens((text.length / CHARS_PER_TOKEN).ceil)} tokens)"
+    end
+
     # A tool's schema in tokens, estimated from its JSON.
     def tokens(entry) = (JSON.generate(entry.schema).length / CHARS_PER_TOKEN).round
 

data/lib/samagotchi/tools/builtins.rb

@@ -103,7 +103,8 @@ module Samagotchi
         end,
         Delegate::NAME => lambda do |call, kctx|
           Delegate.call(call[:content], model: call[:model], session: call[:session], cwd: call[:cwd],
-                                        wait: call[:wait], timeout: call[:timeout], peers: kctx.peers)
+                                        toolkit: call[:toolkit], wait: call[:wait], timeout: call[:timeout],
+                                        peers: kctx.peers)
         end,
         DelegateResult::NAME => lambda do |call, kctx|
           DelegateResult.call(call[:content], session: call[:session], timeout: call[:timeout], peers: kctx.peers)

data/lib/samagotchi/tools/delegate.rb

@@ -19,8 +19,9 @@ module Samagotchi
     # worker, started in this session's folder (or cwd:, a worktree or
     # subfolder of the same repository) with the task as its first
     # user message and the `delegated` system memory preloaded. It shows in
-    # every list as a child of this one and the user can attach to it. With
-    # session:, a follow-up to a child that exists. Only the child's final
+    # every list as a child of this one and the user can attach to it, on
+    # toolkit: (a kit's name) or config's toolkit.child. With session:, a
+    # follow-up to a child that exists. Only the child's final
     # reply comes back (DelegateWait), never its trace.
     class Delegate
       NAME = "delegate"
@@ -41,10 +42,12 @@ module Samagotchi
       # @param model [String, nil] the child's model (an alias works); the parent's by default
       # @param session [String, nil] a child's id or prefix: send the task there instead
       # @param cwd [String, nil] the new child's folder (child_cwd checks it); the parent's by default
+      # @param toolkit [String, nil] the new child's toolkit, a kit's name (checked against the parent's
+      #   kits, Peers#toolkit_names); config's toolkit.child by default
       # @param wait [Boolean, String, nil] wait for the reply (default true)
       # @param timeout [Integer, String, nil] seconds to wait (default DelegateWait::TIMEOUT_DEFAULT)
       # @param peers [Peers, nil]
-      def self.call(content, model: nil, session: nil, cwd: nil, wait: nil, timeout: nil, peers: nil)
+      def self.call(content, model: nil, session: nil, cwd: nil, toolkit: nil, wait: nil, timeout: nil, peers: nil)
         return "Error: this session's id is not known here" unless peers&.session_id
 
         task = content.to_s.strip
@@ -56,10 +59,14 @@ module Samagotchi
         timeout = parse_timeout(timeout)
 
         cwd = cwd.to_s.strip
+        toolkit = toolkit.to_s.strip
         child_id, warning = if session.to_s.strip.empty?
-                              start_child(task, parent: parent, model: model, cwd: cwd, state_dir: sd, peers: peers)
+                              start_child(task, parent: parent, model: model, cwd: cwd, toolkit: toolkit, state_dir: sd,
+                                                peers: peers)
                             elsif !cwd.empty?
                               "Error: cwd starts a new child; a follow-up with session keeps the child's folder"
+                            elsif !toolkit.empty?
+                              "Error: toolkit starts a new child; a follow-up keeps the child's toolkit"
                             else
                               follow_up(task, session: session.to_s.strip, parent: parent, state_dir: sd)
                             end
@@ -106,8 +113,9 @@ module Samagotchi
       end
       private_class_method :full_hint
 
+      # @param toolkit [String] a kit's name, "" for config's toolkit.child
       # @return [String] the new child's id, or an Error: line
-      def self.start_child(task, parent:, model:, cwd:, state_dir:, peers:)
+      def self.start_child(task, parent:, model:, cwd:, toolkit:, state_dir:, peers:)
         if parent.parent_id
           return "Error: this session is a delegate of #{parent.parent_id}; delegated sessions don't delegate further"
         end
@@ -115,6 +123,9 @@ module Samagotchi
         folder = child_cwd(cwd, parent)
         return folder if folder.start_with?("Error:")
 
+        unknown = unknown_toolkit(toolkit, peers)
+        return unknown if unknown
+
         running = running_children(parent.id, state_dir: state_dir)
         max = max_children
         if running.size >= max
@@ -123,14 +134,29 @@ module Samagotchi
                  "(the most is #{max}, #{MAX_CHILDREN_KEY}): #{ids}. #{full_hint(peers)}"
         end
 
+        setup = toolkit.empty? ? SessionSetup.new : SessionSetup.new(toolkit: Toolkit.new(name: toolkit))
         child = SessionManager.spawn_session(prompt: task, working_directory: folder,
                                              model_name: child_model(model, parent), memories: CHILD_MEMORIES,
-                                             parent_id: parent.id, delegate: true, state_dir: state_dir)
+                                             parent_id: parent.id, delegate: true, setup: setup, state_dir: state_dir)
         DelegateWait.mark_started(parent.id, child, state_dir: state_dir)
         [child.id, child.model_warning]
       end
       private_class_method :start_child
 
+      # The Error: line for a toolkit name the parent doesn't know
+      # (Peers#toolkit_names: its built-in, config and plugin kits), nil
+      # when it knows it, none was given, or the peers can't tell (a bare
+      # kernel: the child's worker resolves it, full when it can't).
+      def self.unknown_toolkit(toolkit, peers)
+        return nil if toolkit.empty? || !peers.respond_to?(:toolkit_names)
+
+        names = peers.toolkit_names
+        return nil if names.nil? || names.include?(toolkit)
+
+        "Error: no toolkit named #{toolkit} (toolkits: #{names.join(", ")})"
+      end
+      private_class_method :unknown_toolkit
+
       # The new child's folder: the parent's, or +cwd+ (relative to the
       # parent's) when it is a folder of the parent's repository, in any of
       # its worktrees (one project_root, from the common git dir). Outside

data/lib/samagotchi/tools/list_sessions.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../context_note"
+require_relative "../paths"
 require_relative "../project_scope"
 require_relative "../session"
 require_relative "peers"
@@ -46,7 +46,7 @@ module Samagotchi
                      elsif own&.parent_id && s[:id] == own.parent_id then "  parent"
                      else ""
                      end
-          "#{s[:short_id]}  #{state}  #{s[:busy] ? "running" : "idle"}#{relation}  #{ContextNote.home_relative(s[:cwd])}  #{s[:preview].inspect}"
+          "#{s[:short_id]}  #{state}  #{s[:busy] ? "running" : "idle"}#{relation}  #{Paths.tilde(s[:cwd])}  #{s[:preview].inspect}"
         end
         scope = project ? " in this project (#{File.basename(project)}; cwd \"/\" for every project)" : ""
         <<~TEXT.chomp

data/lib/samagotchi/tools/peers.rb

@@ -11,11 +11,14 @@ module Samagotchi
     # resolved ref, live after /model), and the session's own thinking level
     # (thinking: nil without one) and reasoning_history level
     # (reasoning_history: nil without one), and why the turn was canceled
-    # (cancel_reason: :signal, :manual, …; nil while it runs). Engine hands KernelLoop one that follows its current
+    # (cancel_reason: :signal, :manual, …; nil while it runs), and the
+    # toolkit names the session knows (toolkit_names: the built-in, config
+    # and plugin kits a delegate may name; nil: not known, no check).
+    # Engine hands KernelLoop one that follows its current
     # session (Engine::PeerView); this plain one is for specs and a kernel
     # without an Engine.
     Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, :thinking, :reasoning_history,
-                       :cancel_reason, keyword_init: true) do
+                       :cancel_reason, :toolkit_names, keyword_init: true) do
       # @return [Boolean] the turn was canceled (:cancelled is a proc or a value)
       def cancelled?
         cancelled.respond_to?(:call) ? !!cancelled.call : !!cancelled

data/lib/samagotchi/tools/register_reminder.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "json"
 require_relative "../reminder_store"
 
 module Samagotchi

data/lib/samagotchi/tools/registry.rb

@@ -179,13 +179,24 @@ module Samagotchi
         return true if @index.sourced
         return false if toolkit&.removed&.include?(@index.call_name)
 
-        @entries.each_value.any? { |entry| soft?(entry, [], toolkit) }
+        index_reaches?(toolkit)
       end
 
+      # Whether the index's tools would reach something under +toolkit+,
+      # removed or not: a source registered at load, or a built-in the
+      # toolkit leaves out without removing it.
+      def index_reaches?(toolkit)
+        @index.sourced || @entries.values.any? { |entry| soft?(entry, [], toolkit) }
+      end
+
+      # Not declared by +toolkit+ under +layers+. An index tool counts only
+      # when the toolkit removes it and it would reach something (full with
+      # --no-tool call_tool and no MCP server leaves nothing out).
       def left_out?(entry, layers, toolkit)
         return false unless entry.offered?(layers) && !declared?(entry, toolkit)
+        return true unless index_entry?(entry)
 
-        !index_entry?(entry) || toolkit&.removed&.include?(entry.name) == true
+        toolkit&.removed&.include?(entry.name) == true && index_reaches?(toolkit)
       end
 
       # A built-in +toolkit+ leaves out of a turn under +layers+ without

data/lib/samagotchi/tools/task_wait.rb

@@ -80,13 +80,11 @@ module Samagotchi
       end
       private_class_method :cancelled_response
 
-      # A task the user stopped also says so, with the tail of its output:
-      # the model sees where the job was cut off.
+      # Always give the log's last lines: a test run's summary, an error. A
+      # task the user stopped also says so.
       def self.finished_response(record, tail_lines)
-        return format_response(record) unless record.stopped_by_user?
-
-        format_response(record, output_tail: output_tail(record, tail_lines), tail_lines: tail_lines,
-                               extra: [TaskRuntime::USER_STOP_NOTE])
+        extra = record.stopped_by_user? ? [TaskRuntime::USER_STOP_NOTE] : []
+        format_response(record, output_tail: output_tail(record, tail_lines), tail_lines: tail_lines, extra: extra)
       end
       private_class_method :finished_response
 

data/lib/samagotchi/tools/tool_index.rb

@@ -194,8 +194,6 @@ module Samagotchi
         nil
       end
 
-      def sources = @sources.dup
-
       # Every group, now: the index's own (#registry_groups), then the
       # sources'. A source group with a reserved name, or one an earlier
       # group has, is left out of search, lookup and the description (said
@@ -301,8 +299,14 @@ module Samagotchi
       def call(name, args)
         tool = lookup(name)
         return tool if tool.is_a?(String)
+
         unless claimed(name.strip)&.first == tool.acts_as
-          return "Error: the MCP tools changed while the call waited for its server; call #{tool.full_name} again"
+          # A bare acts_as of a source with no prefix: guardrails can't
+          # name it before its tool is listed (#claimed), so only
+          # <group>/<tool> is taken.
+          return "Error: call #{name.strip} as #{tool.full_name}" if name.strip == tool.acts_as
+
+          return "Error: the tool list changed while the call waited for its server; call #{tool.full_name} again"
         end
         return "Error: #{tool.full_name} can't be called: #{tool.refusal}" if tool.refusal
 
@@ -310,7 +314,11 @@ module Samagotchi
         return "Error: args must be an object.#{ToolIndex.schema_note(tool)}" unless inner
         return "Error: #{tool.full_name} can't be called through #{CALL_NAME} here" if tool.entry
 
-        source_of(tool.group).run(tool, inner)
+        # A publish may drop the group after the lookup.
+        source = source_of(tool.group)
+        return "Error: the tool list changed and #{tool.group} is gone; search with #{FIND_NAME}" unless source
+
+        source.run(tool, inner)
       end
 
       # The built-in a call_tool +call+ names, as the call that runs in its
@@ -534,6 +542,9 @@ module Samagotchi
         return same.first if same.size == 1
         return "Error: #{name} names #{same.map(&:full_name).join(" and ")}; call one as <group>/<tool>" if same.size > 1
 
+        # A built-in the session declares is no starting server's tool.
+        return "Error: #{name} is declared; call it directly" if @registry&.offered(name)&.core?
+
         # A name with a group's <group>/ waits for that group only; any
         # other name (an acts_as) for every one starting.
         named = all.select { |group| name.start_with?("#{group.name}/") }

data/lib/samagotchi/turn_note.rb

@@ -198,8 +198,11 @@ module Samagotchi
 
     # The hidden nudge before a retry of an empty answer (EmptyAnswerRetry):
     # the model never sees its empty generation, so it is told what happened.
+    # It asks to go on with the task, like cut_retry: "answer now" made a
+    # mid-task model stop and report before its last steps.
     def empty_retry
-      retry_nudge(message("your last reply had no visible answer. Answer the user's last message now, briefly."))
+      retry_nudge(message("your last reply had no visible answer. Continue the task with your next tool call, " \
+                          "or answer if it is done."))
     end
 
     # The hidden nudge before a retry of a generation a plugin cut

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.70.0"
+  VERSION = "0.72.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end