samagotchi 0.71.0 → 0.72.0

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/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/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.71.0"
+  VERSION = "0.72.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -46,6 +46,7 @@ require_relative "editor"
 require_relative "message_parts"
 require_relative "session_summary"
 require_relative "../log"
+require_relative "../paths"
 require_relative "../redacted_inspect"
 
 module Samagotchi
@@ -909,7 +910,14 @@ module Samagotchi
         state = nil unless state.is_a?(Hash)
         if state
           status, used, notes = state.values_at("status", "used_memory_names", "prompt_notes")
-          messages = last_assistant_for_display([tail["answer"]].compact)
+          # No session file read here: the folder the answer's file refs must
+          # stay under is the worker's (its tail's working_directory), else the
+          # hub's session list entry's (a worker from before the field, or read
+          # through its snapshot); nil then without a hub or before it saw the
+          # session: refs aren't checked.
+          cwd = tail["working_directory"]
+          cwd = @hub&.working_directory(id) unless cwd.is_a?(String) && !cwd.empty?
+          messages = last_assistant_for_display([tail["answer"]].compact, cwd: cwd)
         else
           session = @session_class.load(id, state_dir: default_state_dir)
           status = displayed_status(session)
@@ -949,9 +957,9 @@ module Samagotchi
       end
 
       # The worker's light read (Bridge GET tail): {"session_state_snapshot",
-      # "answer", "cards", "event_seq", "event_id"}. A worker from before the
-      # route answers 404 not_found: its GET snapshot, in the same shape (the
-      # answer by AnswerTail). Anything else (no worker, a refused connect, a
+      # "working_directory", "answer", "cards", "event_seq", "event_id"}. A
+      # worker from before the route answers 404 not_found: its GET snapshot,
+      # in the same shape (the answer by AnswerTail; no working_directory). Anything else (no worker, a refused connect, a
       # 500, a timeout) is nil: the caller reads the disk, with no second
       # try at a worker that failed once.
       # @return [Hash, nil]
@@ -1998,12 +2006,7 @@ module Samagotchi
         home_label(File.expand_path(default_state_dir))
       end
 
-      def home_label(dir)
-        home = Dir.home
-        return "~" if dir == home
-
-        dir.start_with?("#{home}/") ? "~#{dir.delete_prefix(home)}" : dir
-      end
+      def home_label(dir) = Paths.tilde(dir)
 
       # <body> data for the page: where sessions are stored, where an
       # all-view new chat starts (the server's cwd), and, when ?dir names a

data/lib/samagotchi/web/public/app.js

@@ -38,12 +38,13 @@ import { MODEL_KEY } from "./model_pick.js";
 import { emptySessionState, sessionStateFrom } from "./session_state.js";
 import { createModelPicker } from "./model_picker.js";
 import { chipName, chipsTemplate, imageFiles, restoredChips, thumbsTemplate, turnRefs, turnText, uploadChips } from "./images.js";
-import { normalize, firstPreview, failedTurnText, deleteConfirmText, goneSessionNotice, withLiveStatus, withoutWorker } from "./format.js";
+import { normalize, firstPreview, failedTurnText, deleteConfirmText, goneSessionNotice, cantText, withLiveStatus, withoutWorker } from "./format.js";
 import { createTurnView, turnHistoryNodes } from "./turn_view.js";
 import { elementOf, emptyAnswerTemplate } from "./turn_html.js";
 import { createBubbles, hintEl, outputBubbleTemplate, setBubbleDelivery } from "./bubbles.js";
 import { createCardsPlace } from "./cards_place.js";
 import { createStageView, FOLD_MS } from "./stage_view.js";
+import { reducedMotion, STAGE_GAP } from "./stage_frame.js";
 import { CONTINUE_OPENER, chainNeighbours, isOpener, continueRefusal, continuedText, freshLink, openChildrenTemplate } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
 import { appendQuote } from "./annotations.js";
@@ -313,8 +314,6 @@ const {
 // The plugin cards and a snapshot's notices in the history (cards_place.js).
 const cards = createCardsPlace({
   historyEl,
-  appendToHistory: (el) => appendToHistory(el),
-  isNearBottom: () => isNearBottom(),
   turnDom,
   findInTurnRoots: (selector) => findInTurnRoots(selector),
   selected: () => selected,
@@ -1063,7 +1062,7 @@ async function restartWorker() {
     const result = await restartSession(id);
     showToast(result.version ? `Restarted on chi ${result.version}` : "Restarting: the new worker is starting");
   } catch (e) {
-    showToast(`Can't restart: ${String(e.message).replace(/ \(\d+\)$/, "")}`, null, { sticky: true });
+    showToast(cantText("restart", e), null, { sticky: true });
   } finally {
     restartingIds.delete(id);
     updateInfoBar();
@@ -1482,6 +1481,8 @@ const composerCommands = createComposerCommands({
   followWokenWorker: () => followWokenWorker(),
   refreshHistory: () => refreshHistory(),
   failed: (line, text) => addCommandBubble({ label: null, line, text, failed: true }),
+  // As handleSendTurn says a turn's failure after a switch.
+  failedElsewhere: (line, text) => alert(`${line}: ${text}`),
   ownedByTui: () => {
     current.owner = "tui";
     updateComposerMode();
@@ -1742,7 +1743,6 @@ const centerEl = $("#center");
 // A leaving stage (the hand-off's slide) no longer counts: the reserve eases
 // down over the slide (index.html, #center.reserve-easing).
 const stageEl = view === "stage" ? turnDom.root : null;
-const STAGE_GAP = 10;
 function dockReserve() {
   const shown = stageEl && !stageEl.hidden && !stageEl.classList.contains("leaving");
   return dockEl.offsetHeight + (shown ? stageEl.offsetHeight + STAGE_GAP : 0);
@@ -1760,7 +1760,7 @@ function updateReserve({ fromStage = false } = {}) {
   const changed = centerEl.style.getPropertyValue("--dock-h") !== reserve;
   if (changed) centerEl.style.setProperty("--dock-h", reserve);
   if (changed && follow) {
-    if (fromStage) easeScrollTo(historyEl, historyEnd, { ms: leaving ? FOLD_MS : FOLLOW_MS, reduce: matchMedia("(prefers-reduced-motion: reduce)").matches });
+    if (fromStage) easeScrollTo(historyEl, historyEnd, { ms: leaving ? FOLD_MS : FOLLOW_MS, reduce: reducedMotion() });
     else if (historyEl.dataset.following === undefined) historyEl.scrollTop = historyEl.scrollHeight;
   }
   placeToast();
@@ -1864,12 +1864,11 @@ $("#infoStopBtn").addEventListener("click", async () => {
   stoppingId = id;
   try {
     await stopSession(id);
-    if (id === selected) {
-      // The worker is gone: don't wait for its stream to notice.
-      streamControl?.close();
-      current.status = "stopped";
-      workerGone(id);
-    }
+    if (id === selected) stoppedWorker(id);
+  } catch (e) {
+    // A refusal (a terminal holds it) or a worker that won't stop: said, as
+    // a failed restart is.
+    showToast(cantText(`stop ${id.slice(0, 8)}`, e), null, { sticky: true });
   } finally {
     stoppingId = null;
   }
@@ -1963,6 +1962,14 @@ function markArchived(ids, archived) {
 // and a batch share. The ids in the answer flip in the list at once. When
 // the open session's worker was stopped (it, or a delegate of the archived
 // one), its stream ending is a stop, not a lost worker.
+// The open session's worker was stopped from here (the stop button, an
+// archive): don't wait for its stream to notice.
+function stoppedWorker(id) {
+  streamControl?.close();
+  current.status = "stopped";
+  workerGone(id);
+}
+
 // @return {ok: true, result} | {ok: false, error}
 async function archiveOne(id, archive) {
   // A live worker in the tree is stopped by the archive: the open
@@ -1972,12 +1979,7 @@ async function archiveOne(id, archive) {
   try {
     const result = archive ? await archiveSession(id) : await unarchiveSession(id);
     markArchived(archive ? result.archived : result.unarchived, archive);
-    if (mine && mine === selected && (result.stopped || []).includes(mine)) {
-      // Its worker is gone: don't wait for its stream to notice.
-      streamControl?.close();
-      current.status = "stopped";
-      workerGone(mine);
-    }
+    if (mine && mine === selected && (result.stopped || []).includes(mine)) stoppedWorker(mine);
     return { ok: true, result };
   } catch (error) {
     return { ok: false, error };

data/lib/samagotchi/web/public/bubbles.js

@@ -285,7 +285,7 @@ export function createBubbles({
   }
 
   return {
-    removeHintIfEmpty, appendChunk, addEndBubble, makeUserBubble, bubbleById, applyPromptOps, showRecap,
+    removeHintIfEmpty, placeFollowing, appendChunk, addEndBubble, makeUserBubble, bubbleById, applyPromptOps, showRecap,
     markRecapStale, showGuardrailWarning, showSteers, showHookNotice, addCommandBubble, commandBubble, addNoteBubble,
   };
 }