samagotchi 0.71.0 → 0.73.0

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])

data/lib/samagotchi/tool_activity.rb

@@ -405,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/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,17 +251,20 @@ 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].freeze
+    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. One with another key (a
-    # typo, a tools: list) still loads, with a line naming the key.
+    # 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 or unknown key
@@ -249,14 +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:)"
+            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/execute.rb

@@ -350,7 +350,7 @@ module Samagotchi
         return nil if error
 
         File.write(File.join(dir, BACK_POINTER), File.expand_path(TaskRuntime.metadata_path(record.id)))
-        write_missing_exit_code(waiter, record.exit_code_path)
+        TaskRuntime.record_exit_status(waiter, record.exit_code_path, task_id: record.id)
         # Ended between the deadline and the adopt: the record says how.
         TaskRuntime.get_record(record.id) unless waiter.alive?
         lines = [handed_over_line(timeout_sec), "task_id: #{record.id}",
@@ -363,20 +363,6 @@ module Samagotchi
       end
       private_class_method :hand_over
 
-      # A command that set its own EXIT trap replaced the wrapper's, so it
-      # writes no exit_code: while this chi lives, the waiter's status fills
-      # it in (a refresh in between may still read "no exit code").
-      def self.write_missing_exit_code(waiter, path)
-        Thread.new do
-          Thread.current.report_on_exception = false
-          code = waiter.value&.exitstatus
-          File.write(path, code.to_s) if code && !File.exist?(path) && Dir.exist?(File.dirname(path))
-        rescue StandardError => e
-          Log.debug(:turn, "execute_exit_code_failed", error: e.class.name, msg: e.message)
-        end
-      end
-      private_class_method :write_missing_exit_code
-
       # <state dir>/execute: every command's dir (LOGS_DIRNAME).
       def self.logs_root = File.join(Paths.state_dir, LOGS_DIRNAME)
 

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

@@ -186,7 +186,7 @@ module Samagotchi
       # 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.each_value.any? { |entry| soft?(entry, [], toolkit) }
+        @index.sourced || @entries.values.any? { |entry| soft?(entry, [], toolkit) }
       end
 
       # Not declared by +toolkit+ under +layers+. An index tool counts only

data/lib/samagotchi/tools/task_runtime.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "shellwords"
 require "time"
 require_relative "../atomic_file"
+require_relative "../log"
 require_relative "../process_group"
 require_relative "shell"
 require_relative "task_record"
@@ -55,7 +56,9 @@ module Samagotchi
         task_id = generate_task_id
         task_dir = task_dir_for(task_id)
         output_path = File.join(task_dir, OUTPUT_FILENAME)
-        exit_code_path = File.join(task_dir, EXIT_CODE_FILENAME)
+        # Absolute: the trap writes it wherever the shell is when it exits
+        # (a +cwd+, or a cd in the command). Ruby opens output_path here.
+        exit_code_path = File.expand_path(File.join(task_dir, EXIT_CODE_FILENAME))
 
         FileUtils.mkdir_p(task_dir)
 
@@ -72,7 +75,7 @@ module Samagotchi
           out: output_io,
           err: output_io
         )
-        Process.detach(pid)
+        waiter = Process.detach(pid)
         # Read now, compared before each signal: a pid reused later is not this task.
         pid_started = ProcessGroup.start_time(pid)
 
@@ -81,6 +84,7 @@ module Samagotchi
                                     output_path: output_path, exit_code_path: exit_code_path)
 
         write_record(record)
+        record_exit_status(waiter, exit_code_path, task_id: task_id)
         [record, nil]
       rescue StandardError => e
         [nil, "Error: #{e.message}"]
@@ -88,6 +92,60 @@ module Samagotchi
         output_io&.close
       end
 
+      # The shell's status from chi's waiter (+waiter+, a Process.detach
+      # thread), for a shell whose EXIT trap wrote nothing: one killed by a
+      # signal (zsh's sh mode skips the trap on TERM, INT and KILL) gets
+      # 128 + the signal, one whose command replaced the trap gets its exit
+      # status. Only while this chi runs. A record a refresh finished in
+      # between (failed, no exit code) is corrected; a stopped task (its
+      # stop flag on disk) is left as task_stop records it.
+      # @return [Thread]
+      def record_exit_status(waiter, path, task_id:)
+        # Absolute now: safe against a later chdir.
+        record_path = File.expand_path(metadata_path(task_id))
+        path = File.expand_path(path)
+        Thread.new do
+          Thread.current.report_on_exception = false
+          code = status_code(waiter.value)
+          next if code.nil? || record_at(record_path)&.stop_requested_by
+
+          File.write(path, code.to_s) if !File.exist?(path) && Dir.exist?(File.dirname(path))
+          correct_finished_record(record_path, read_exit_code(path))
+        rescue StandardError => e
+          Log.debug(:turn, "task_exit_code_failed", id: task_id, error: e.class.name, msg: e.message)
+        end
+      end
+
+      # A Process::Status as a shell reports one: its exit status, or
+      # 128 + the signal that killed it.
+      def status_code(status)
+        return nil unless status
+
+        status.exitstatus || (status.termsig && (128 + status.termsig))
+      end
+
+      # Reasons a refresh finishes a record with when it read no exit code.
+      MISSING_CODE_REASONS = ["process_ended_without_exit_code", NOT_CHIS_PROCESS].freeze
+
+      # A record a refresh finished before the exit code was there (failed,
+      # exit_code nil, no stop) gets +code+; finished_at is kept.
+      def correct_finished_record(record_path, code)
+        record = record_at(record_path)
+        return unless code && record && !record.running? && record.exit_code.nil? && !record.stop_requested_by
+        return unless MISSING_CODE_REASONS.include?(record.stop_reason)
+
+        status = code.zero? ? "completed" : "failed"
+        AtomicFile.write(record_path, record_json(record.with(status: status, exit_code: code, stop_reason: nil)))
+      end
+
+      def record_at(path)
+        return nil unless File.file?(path)
+
+        TaskRecord.from_file(JSON.parse(File.read(path)))
+      rescue JSON::ParserError
+        nil
+      end
+
       # A record for a command chi already runs: an execute still running at
       # its limit, handed over as a task (Execute::HANDED_OVER), given as a
       # TaskRecord.running whose +started_at+ is the spawn's. Its logs and
@@ -321,9 +379,11 @@ module Samagotchi
         FileUtils.mkdir_p(dir)
 
         path = File.join(dir, METADATA_FILENAME)
-        AtomicFile.write(path, JSON.pretty_generate(record.to_file) + "\n")
+        AtomicFile.write(path, record_json(record))
       end
 
+      def record_json(record) = JSON.pretty_generate(record.to_file) + "\n"
+
       def metadata_path(task_id)
         File.join(task_dir_for(task_id), METADATA_FILENAME)
       end
@@ -352,9 +412,12 @@ module Samagotchi
       # exit status to +exit_code_path+. A prefix, not lines after the
       # command: a trailing "\\" or "|" in the command would swallow those,
       # and an `exit N` or a `set -e` failure would skip them. A command that
-      # sets its own EXIT trap replaces this one: no exit_code file then
-      # (the task ends failed with process_ended_without_exit_code, unless
-      # its starter's waiter writes the code: Execute's hand-over).
+      # sets its own EXIT trap replaces this one, and a shell killed by a
+      # signal skips it (zsh's sh mode, on TERM, INT and KILL): no exit_code
+      # file from the shell then. The waiter of the chi that started it
+      # writes the code instead (record_exit_status: the status, or
+      # 128 + the signal); with that chi gone too, the task ends failed with
+      # process_ended_without_exit_code.
       def wrapped_shell_command(command, exit_code_path)
         write = %(printf "%s" "$?" > #{Shellwords.escape(exit_code_path)})
         "trap #{Shellwords.escape(write)} EXIT\n#{command}\n"

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}/") }