samagotchi 0.120.0 → 0.121.1

data/lib/samagotchi/toolkit_binding.rb

@@ -116,8 +116,10 @@ module Samagotchi
       errors = []
       resolved = Toolkit.of(session&.toolkit).resolve(kits(errors))
       warn_unresolved(session, resolved, errors, on_event)
+      warn_unknown_groups(resolved, on_event)
       resolved = nil if resolved.everything?
       tools = @tools.call
+      tools.reaching_kit = ->(group) { reaching_kit(group) }
       return false if resolved == tools.toolkit
 
       tools.toolkit = resolved
@@ -126,6 +128,19 @@ module Samagotchi
       true
     end
 
+    # The first kit that resolves and reaches source group +group+, the
+    # user's own (config's, the plugins') before the built-ins, so a hint
+    # names "/toolkit web" rather than "full"; nil when none does.
+    def reaching_kit(group)
+      kits = self.kits
+      builtin = Toolkit::BUILTIN_KITS.keys
+      kits.keys.sort_by.with_index { |name, i| [builtin.include?(name) ? 1 : 0, i] }.find do |name|
+        Toolkit.resolve_kit(name, kits).reaches_group?(group)
+      rescue Toolkit::Unresolved
+        false
+      end
+    end
+
     private
 
     # The toolkit's load warnings, each once per process: a name that
@@ -142,5 +157,22 @@ module Samagotchi
         @emit.call(on_event, { type: :guardrail_warning, message: line, label: "toolkit" })
       end
     end
+
+    def warn_unknown_groups(resolved, on_event)
+      return if resolved.groups == :all
+
+      names = @tools.call.index&.groups || []
+      unknown = resolved.groups.reject do |selector|
+        names.any? { |name| Toolkit.group_matches?([selector], name) }
+      end
+      unknown.each do |selector|
+        line = "#{resolved.name}: group selector #{selector.inspect} matches no group declared at load"
+        next if @warned.include?(line)
+
+        @warned << line
+        Log.warn(:config, "toolkit_group_unknown", message: line)
+        @emit.call(on_event, { type: :guardrail_warning, message: line, label: "toolkit" })
+      end
+    end
   end
 end

data/lib/samagotchi/toolkit_command.rb

@@ -71,6 +71,15 @@ module Samagotchi
       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
+      groups = explained.resolved.groups
+      group_names = if groups == :all
+                      "all"
+                    elsif groups.empty?
+                      "none"
+                    else
+                      groups.join(", ")
+                    end
+      lines << "  groups: #{group_names}"
       left_out = explained.left_out
       if explained.reachable.empty?
         lines << "  not loaded: #{left_out.empty? ? "none" : left_out.join(", ")}"
@@ -123,10 +132,24 @@ module Samagotchi
       # 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.concat(group_changes(before.resolved.groups, after.resolved.groups))
       parts << "declares the same tools under its own name" if parts.empty?
       "Switching to #{after.toolkit.label} #{parts.join("; ")}."
     end
 
+    def group_changes(before, after)
+      return [] if before == after
+      return ["reaches all groups"] if after == :all
+      return ["limits groups to #{after.empty? ? "none" : after.join(", ")}"] if before == :all
+
+      added = after - before
+      removed = before - after
+      changes = []
+      changes << "reaches groups #{added.join(", ")}" unless added.empty?
+      changes << "leaves out groups #{removed.join(", ")}" unless removed.empty?
+      changes
+    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#tools_key is unchanged: only a kit's prompt text).

data/lib/samagotchi/tools/deferred_tools.rb

@@ -39,7 +39,7 @@ module Samagotchi
           next if taken.include?(name) || registry.offered(name, layers: layers)
 
           taken << name
-          deferred << Deferred.new(name: name, description: STUB_DESCRIPTION, schema: STUB_SCHEMA)
+          deferred << Deferred.new(name: name, description: stub_description(registry, name), schema: STUB_SCHEMA)
         end
         deferred
       end
@@ -74,7 +74,15 @@ module Samagotchi
         end
       end
 
-      private_class_method :builtins, :sourced
+      def stub_description(registry, name)
+        index = registry.respond_to?(:index) ? registry.index : nil
+        tool = index&.unreached_tool(name)
+        return STUB_DESCRIPTION unless tool
+
+        ToolIndex::ToolkitGroupRefusal.for(tool, registry).stub_description
+      end
+
+      private_class_method :builtins, :sourced, :stub_description
     end
   end
 end

data/lib/samagotchi/tools/delegate.rb

@@ -81,7 +81,7 @@ module Samagotchi
         started = session.to_s.strip.empty? ? "Started a delegate session" : "Sent the follow-up to delegate #{child_id[0, 8]}"
         "#{note}session: #{child_id}\nstatus: running\n#{started}; #{running_hint(peers)} " \
           "It shows in chi sessions list and the web as a child of this session; the user can attach to it."
-      rescue ArgumentError => e
+      rescue ArgumentError, Toolkit::Refused => e
         "Error: #{e.message}"
       end
 

data/lib/samagotchi/tools/delegate_relay.rb

@@ -2,6 +2,7 @@
 
 require_relative "../session"
 require_relative "../bridge_client"
+require_relative "../worker_link"
 require_relative "../relay"
 require_relative "../guardrails/approval"
 require_relative "../guardrails/parent_policy"
@@ -79,13 +80,14 @@ module Samagotchi
         qid = question.id.to_s
         desk = relay.relay_desk
         relay_id = desk.open(child_id: child_id, child_question_id: qid)
-        client = BridgeClient.discover(child_id, session_dir: Session.session_dir(child_id, state_dir: state_dir))
+        client = WorkerLink.client(child_id, session_dir: Session.session_dir(child_id, state_dir: state_dir))
         post(client, "opened", relay_id, qid)
         Log.info(:turn, "relay_opened", child: child_id[0, 8], id: qid)
 
         fields = Relay.card(child, question, relay_id: relay_id, more: more)
         answer = relay.open_question(fields, watch: watch(child_id, qid, state_dir))
-        settle(answer, fields, label: label(question), client: client, desk: desk, relay_id: relay_id, qid: qid)
+        settle(answer, fields, label: label(question), client: client, desk: desk, relay_id: relay_id, qid: qid,
+                        child_id: child_id)
       ensure
         # A relay that failed before it settled closes, so the desk (which
         # prunes only settled ones) keeps none open; a settled one stays.
@@ -96,7 +98,7 @@ module Samagotchi
       # was answered or cancelled there) or its worker is gone.
       def watch(child_id, qid, state_dir)
         lambda do
-          unless SessionManager.worker_live?(child_id, state_dir: state_dir)
+          unless WorkerLink.resolve(Session.session_dir(child_id, state_dir: state_dir), unlink: false).worker_owned?
             next "child_gone"
           end
 
@@ -109,7 +111,7 @@ module Samagotchi
 
       # Record the parent's answer, tell the child, and say what came of it.
       # @param label [String] the outcome line's start (#label)
-      def settle(answer, fields, label:, client:, desk:, relay_id:, qid:)
+      def settle(answer, fields, label:, client:, desk:, relay_id:, qid:, child_id:)
         if answer.is_a?(Hash) && answer[:error] == "cancelled"
           desk.close(relay_id)
           return closed(answer[:reason].to_s, label, client: client, relay_id: relay_id, qid: qid)
@@ -120,7 +122,7 @@ module Samagotchi
         desk.record(relay_id, selected_indices: dismissed ? [] : answer.selected_indices,
                               freeform: dismissed ? nil : answer.freeform, dismissed: dismissed, by: by)
         response = post(client, "answered", relay_id, qid)
-        Outcome.new(line: line(label, delivered(response, answer, fields, dismissed)), stopped: false)
+        Outcome.new(line: line(label, delivered(response, answer, fields, dismissed, child_id)), stopped: false)
       end
 
       def closed(reason, label, client:, relay_id:, qid:)
@@ -136,12 +138,12 @@ module Samagotchi
       end
 
       # The outcome of an answer the child was told about.
-      def delivered(response, answer, fields, dismissed)
+      def delivered(response, answer, fields, dismissed, child_id)
         return "not delivered (the child's worker is gone)" unless response
 
         # The child's Bridge asked for a secret this worker didn't send (one
         # from before the child's chi): not the child's guardrails refusing.
-        return "not delivered (#{BridgeSecret::REFUSED})" if response.secret_refused?
+        return "not delivered (#{BridgeSecret.refused(child_id)})" if response.secret_refused?
 
         hook = fields[:kind] == HOOK_KIND
         case response.status

data/lib/samagotchi/tools/registry.rb

@@ -40,13 +40,18 @@ module Samagotchi
 
       # What Tools::ToolIndex#declare registered: the entries of +source+
       # are the index's search and call tools, +call_name+ the call tool's
-      # name, and +sourced+ whether a source (an MCP server's bundle)
-      # registered when the plugins loaded. +deferrable+ (→ the sources'
+      # name, and +groups+ the source groups registered when the plugins
+      # loaded. +deferrable+ (→ the sources'
       # tools a host that loads tools may declare deferred) and +wrap+
       # (call → the call_tool call a direct call of one of them runs as, or
       # nil) are nil when nothing reaches them.
-      Index = Data.define(:source, :call_name, :sourced, :deferrable, :wrap) do
-        def initialize(source:, call_name:, sourced:, deferrable: nil, wrap: nil) = super
+      Index = Data.define(:source, :call_name, :groups, :deferrable, :wrap, :unreached) do
+        def initialize(source:, call_name:, groups:, deferrable: nil, wrap: nil, unreached: nil)
+          super(source: source, call_name: call_name, groups: Array(groups).map(&:to_s).uniq.freeze,
+                deferrable: deferrable, wrap: wrap, unreached: unreached)
+        end
+
+        def unreached_tool(name) = unreached&.call(name)
       end
 
       def initialize
@@ -64,6 +69,11 @@ module Samagotchi
       # only there: a request's declared tools never change mid-turn.
       attr_accessor :toolkit
 
+      # Which kit reaches a source group: a lookup (group name → kit name,
+      # nil when none does) the Engine sets with the toolkit; a refusal's
+      # hint names it.
+      attr_accessor :reaching_kit
+
       # @return [Entry]
       def register(name, schema:, handler:, label: nil, preview: nil, targets: nil, refs: nil, source: "core", layer: nil,
                    unwrap: nil)
@@ -181,7 +191,7 @@ module Samagotchi
       # the declared tools stay the same for a session's life. A built-in
       # left out counts only while call_tool can reach it (not removed).
       def index_needed?(toolkit)
-        return true if @index.sourced
+        return true if reached_groups?(toolkit)
         return false if toolkit&.removed&.include?(@index.call_name)
 
         index_reaches?(toolkit)
@@ -191,7 +201,11 @@ 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.values.any? { |entry| soft?(entry, [], toolkit) }
+        reached_groups?(toolkit) || @entries.values.any? { |entry| soft?(entry, [], toolkit) }
+      end
+
+      def reached_groups?(toolkit)
+        @index.groups.any? { |name| toolkit.nil? || toolkit.reaches_group?(name) }
       end
 
       # Not declared by +toolkit+ under +layers+. An index tool counts only

data/lib/samagotchi/tools/tool_index.rb

@@ -63,6 +63,37 @@ module Samagotchi
         args: { type: "object", description: "the arguments, per the inputSchema #{FIND_NAME} gave" }
       }.freeze
 
+      # The user changes kits; calls and old deferred references cannot
+      # make a source group reachable again.
+      class ToolkitGroupRefusal < StandardError
+        RULE = "toolkit-group"
+
+        # The refusal of +tool+ under +registry+'s toolkit, naming a kit that
+        # reaches its group when the registry can tell (Registry#reaching_kit).
+        def self.for(tool, registry)
+          new(tool, registry.toolkit, kit: registry.respond_to?(:reaching_kit) ? registry.reaching_kit&.call(tool.group) : nil)
+        end
+
+        def initialize(tool, toolkit, kit: nil)
+          @tool = tool
+          @toolkit = toolkit.name
+          @kit = kit
+          super("Error: #{tool.full_name} isn't in this session's toolkit (#{@toolkit}); #{hint}.")
+        end
+
+        def stub_description
+          "Not available in this session's toolkit (#{@toolkit}); #{hint}."
+        end
+
+        private
+
+        def hint
+          return "only the user can switch (/toolkit NAME, or a kit that reaches #{@tool.group})" unless @kit
+
+          "only the user can switch (/toolkit #{@kit}, which reaches #{@tool.group})"
+        end
+      end
+
       # One tool in the index: +group+/+name+ is what the call tool takes,
       # +schema+ its inputSchema, +acts_as+ the name guardrail rules match
       # (mcp_<server>_<tool>; a bare name the call tool looks up too).
@@ -141,7 +172,7 @@ module Samagotchi
       # yet). +prefix+: a bare name with it is taken as an acts_as as given.
       # +label+ is the call tool's row label.
       class Source
-        attr_reader :label, :prefix, :context, :groups, :declared_names, :declared_tokens
+        attr_reader :label, :prefix, :context, :groups, :declared_names, :declared_tokens, :declared_groups
 
         def initialize(label:, call:, acts_as:, wait: nil, prefix: nil, context: nil)
           raise ArgumentError, "tool_source: call must respond to #call" unless call.respond_to?(:call)
@@ -157,6 +188,7 @@ module Samagotchi
           @groups = [].freeze
           @declared_names = []
           @declared_tokens = 0
+          @declared_groups = [].freeze
         end
 
         def inspect = "#<ToolIndex::Source #{@label} groups=#{@groups.map(&:name).join(",")}>"
@@ -184,9 +216,10 @@ module Samagotchi
 
         # What ToolIndex#declare registered: the tools' names and their
         # definitions' estimated tokens (the mcp bundle's /mcp says them).
-        def declared!(names, tokens)
+        def declared!(names, tokens, groups)
           @declared_names = names.dup.freeze
           @declared_tokens = tokens
+          @declared_groups = groups.dup.freeze
         end
       end
 
@@ -196,7 +229,8 @@ module Samagotchi
         @registry = nil
         # The source groups' lines in the search tool's description, as
         # #declare found them (#find_description).
-        @described = [].freeze
+        @described = {}.freeze
+        @declared_group_names = nil
         @dropped = []
         @dropped_mutex = Mutex.new
       end
@@ -216,7 +250,7 @@ module Samagotchi
       # sources'. A source group with a reserved name, or one an earlier
       # group has, is left out of search, lookup and the description (said
       # once per name: a source publishes after load too).
-      def groups
+      def all_groups
         own = registry_groups
         taken = own.map(&:name) | RESERVED_GROUPS
         kept = @sources.flat_map(&:groups).select do |group|
@@ -230,6 +264,17 @@ module Samagotchi
         own + kept
       end
 
+      def reached_groups
+        groups = all_groups
+        toolkit = @registry&.toolkit
+        return groups if toolkit.nil? || toolkit.groups == :all
+
+        declared = @declared_group_names || groups.reject { |group| own?(group) }.map(&:name)
+        groups.select do |group|
+          own?(group) || (declared.include?(group.name) && toolkit.reaches_group?(group.name))
+        end
+      end
+
       # Register the search and call tools in +registry+, once, after the
       # plugins load (or without them: the built-ins a toolkit leaves out
       # are reachable either way); +registry+ declares them per toolkit
@@ -238,7 +283,8 @@ module Samagotchi
       # @return [Array<String>] the names registered
       def declare(registry, failures: nil)
         @registry = registry
-        @described = description_lines(groups.reject { |group| own?(group) }).freeze
+        @described = description_lines(all_groups.reject { |group| own?(group) }).freeze
+        @declared_group_names = @described.keys.freeze
         specs = [find_spec, call_spec]
         declared = specs.filter_map do |spec|
           if (taken = registry[spec.name])
@@ -251,8 +297,9 @@ module Samagotchi
           registry.register(spec.name, source: SOURCE, unwrap: unwrap, **spec.entry_fields(nil))
           spec
         end
-        registry.index = Registry::Index.new(source: SOURCE, call_name: CALL_NAME, sourced: !@sources.empty?,
-                                             deferrable: -> { deferrable }, wrap: ->(call) { wrap(call) })
+        registry.index = Registry::Index.new(source: SOURCE, call_name: CALL_NAME, groups: @declared_group_names,
+                                             deferrable: -> { deferrable }, wrap: ->(call) { wrap(call) },
+                                             unreached: ->(name) { unreached_tool(name) })
         declared!(declared)
         declared.map(&:name)
       end
@@ -293,7 +340,7 @@ module Samagotchi
       def find_description
         "Search tools this session doesn't declare, by keywords. It answers up to #{FIND_RESULTS} tools, each with " \
           "its name (<group>/<tool>) and inputSchema; call one with #{CALL_NAME}. An empty query lists every tool's " \
-          "name.\nGroups:\n#{(description_lines(registry_groups) + @described).join("\n")}"
+          "name.\nGroups:\n#{(description_lines(registry_groups).values + described_groups.values).join("\n")}"
       end
 
       # ── Search ──────────────────────────────────────────────────────────
@@ -372,9 +419,10 @@ module Samagotchi
       # same list in any session and after a respawn.
       # @return [Array<Tool>]
       def deferrable
-        tools = groups.reject { |group| own?(group) }.flat_map(&:tools)
-        counts = tools.map(&:acts_as).tally
-        tools.select do |tool|
+        all = all_groups.reject { |group| own?(group) }.flat_map(&:tools)
+        reached = reached_groups.reject { |group| own?(group) }.flat_map(&:tools)
+        counts = all.map(&:acts_as).tally
+        reached.select do |tool|
           tool.refusal.nil? && counts[tool.acts_as] == 1 && tool.acts_as.match?(DEFERRABLE_NAME) &&
             !@registry&.key?(tool.acts_as)
         end.sort_by(&:acts_as)
@@ -397,6 +445,22 @@ module Samagotchi
         deferrable.any? { |t| t.acts_as == tool.acts_as } ? tool.acts_as : nil
       end
 
+      # Finds a source tool regardless of the active toolkit, without
+      # waiting for a starting group. Used only to refuse a call or explain
+      # a deferred stub for a group the session cannot reach.
+      def unreached_tool(name)
+        name = name.to_s.strip
+        return nil if name.empty?
+
+        groups = all_groups.reject { |group| own?(group) }
+        groups.select! { |group| @declared_group_names.include?(group.name) } if @declared_group_names
+        tool = tool_in(name, groups)
+        return nil unless tool
+        return nil if reached_groups.any? { |group| group.name == tool.group }
+
+        tool
+      end
+
       # What a deferred source tool's wire name may be (Messages' tool
       # name rule).
       DEFERRABLE_NAME = /\A[a-zA-Z0-9_-]{1,128}\z/
@@ -466,7 +530,7 @@ module Samagotchi
       end
 
       def find_in(query, only)
-        all = groups
+        all = reached_groups
         searched = all
         if only && !only.strip.empty?
           searched = all.select { |group| group.name == only.strip }
@@ -502,7 +566,14 @@ module Samagotchi
       def declared!(specs)
         names = specs.map(&:name)
         tokens = specs.sum { |spec| ToolIndex.spec_tokens(spec) }
-        @sources.each { |source| source.declared!(names, tokens) }
+        groups = reached_groups.reject { |group| own?(group) }.map(&:name)
+        @sources.each { |source| source.declared!(names, tokens, groups) }
+      end
+
+      def described_groups
+        return @described unless @registry&.toolkit && @registry.toolkit.groups != :all
+
+        @described.select { |name, _line| @registry.toolkit.reaches_group?(name) }
       end
 
       def own?(group) = RESERVED_GROUPS.include?(group.name)
@@ -536,16 +607,16 @@ module Samagotchi
       # One line per group in the search tool's description: its name, its
       # summary and how many tools it can call.
       def description_lines(groups)
-        groups.map do |group|
+        groups.to_h do |group|
           count = group.callable.size
           line = "- #{group.name}"
           line += ": #{group.summary}" if group.summary
           line += " (#{count} tool#{"s" unless count == 1})" unless group.tools.empty?
-          line
+          [group.name, line]
         end
       end
 
-      # Say once per name that a source's group was left out (#groups).
+      # Say once per name that a source's group was left out (#all_groups).
       def dropped(name, why)
         first = @dropped_mutex.synchronize { @dropped.include?(name) ? false : (@dropped << name) }
         return unless first
@@ -614,7 +685,7 @@ module Samagotchi
       # @return [Tool, String]
       def lookup(name, waited: false)
         name = name.strip
-        all = groups
+        all = reached_groups
         tool = all.lazy.filter_map do |group|
           next unless name.start_with?("#{group.name}/")
 
@@ -632,8 +703,8 @@ module Samagotchi
 
         # 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}/") }
-        starting = (named.empty? ? all : named).select { |group| group.state == :starting }
+        named = reached_groups.select { |group| name.start_with?("#{group.name}/") }
+        starting = (named.empty? ? reached_groups : named).select { |group| group.state == :starting }
         unless waited || starting.empty?
           starting.each { |group| source_of(group.name)&.wait(group.name) }
           return lookup(name, waited: true)
@@ -654,6 +725,18 @@ module Samagotchi
         tool.is_a?(Tool) ? tool : nil
       end
 
+      def tool_in(name, groups)
+        named = groups.filter_map do |group|
+          next unless name.start_with?("#{group.name}/")
+
+          group.tools.find { |tool| tool.name == name.delete_prefix("#{group.name}/") }
+        end
+        return named.first if named.one?
+
+        same = groups.flat_map(&:tools).select { |tool| tool.acts_as == name }
+        same.first if same.one?
+      end
+
       # The acts_as and label +name+ stands for, from the name alone:
       # <group>/<tool> of a known group (the one that has the tool, else the
       # first whose name it starts with), its source naming the acts_as; a
@@ -662,7 +745,7 @@ module Samagotchi
       # anything else.
       # @return [Array(String, String), Array(String, nil), nil]
       def claimed(name)
-        all = groups
+        all = all_groups
         if (own = all.select { |g| own?(g) }.find { |g| g.tools.any? { |t| t.acts_as == name } })
           return [name, "#{own.name}: #{name}"]
         end

data/lib/samagotchi/turn_checkpoint.rb

@@ -93,8 +93,9 @@ module Samagotchi
       SessionInbox.prune_old(session_dir, SETTLED_DIR, max_age: max_age)
     end
 
-    def self.settled_record(id, ended_at: nil, seconds: nil)
-      LastTurn.new(outcome: "canceled", cancel_reason: WORKER_STOPPED, ended_at: ended_at, seconds: seconds, enqueued_id: id)
+    def self.settled_record(id, ended_at: nil, seconds: nil, author: nil)
+      LastTurn.new(outcome: "canceled", cancel_reason: WORKER_STOPPED, ended_at: ended_at, seconds: seconds, enqueued_id: id,
+                   author: author)
     end
     private_class_method :settled_record
 
@@ -123,13 +124,15 @@ module Samagotchi
 
     # A participant's queued turn the worker refused (Worker#refuse_participant_turn:
     # +reason+ revoked or cap_reached) ends its sender's wait: no turn ran,
-    # canceled for that reason (ParentReport reads it as refused).
-    def self.record_refused(session_dir, enqueued_id, reason:)
+    # canceled for that reason (ParentReport reads it as refused). Its
+    # +author+ (the participant's "p:<id>") says whose wait it is to a chi
+    # web restarted since (ParticipantAccess#turn_author).
+    def self.record_refused(session_dir, enqueued_id, reason:, author: nil)
       id = enqueued_id.to_s
       return unless SessionInbox::ENQUEUED_ID_NAME.match?(id)
 
       write_settled(session_dir, id, LastTurn.new(outcome: "canceled", cancel_reason: reason.to_s,
-                                                  ended_at: Time.now.iso8601(3), enqueued_id: id))
+                                                  ended_at: Time.now.iso8601(3), enqueued_id: id, author: author))
     rescue SystemCallError, IOError => e
       Log.warn(:worker, "refused_turn_write_failed", error: e.class.name, msg: e.message, enqueued_id: id)
     end
@@ -138,7 +141,7 @@ module Samagotchi
       id = mark.enqueued_id.to_s
       return unless SessionInbox::ENQUEUED_ID_NAME.match?(id)
 
-      write_settled(session_dir, id, settled_record(id, ended_at: Time.now.iso8601(3), seconds: seconds))
+      write_settled(session_dir, id, settled_record(id, ended_at: Time.now.iso8601(3), seconds: seconds, author: mark.author))
     rescue SystemCallError => e
       # The settle goes on; a wait for that turn runs to its timeout.
       Log.warn(:worker, "settled_turn_write_failed", error: e.class.name, msg: e.message)
@@ -163,6 +166,7 @@ module Samagotchi
       @written_at = nil
       @started_at = nil
       @enqueued_id = nil
+      @author = nil
     end
 
     # A turn begins (before Engine#run_turn and the worker's running save):
@@ -170,7 +174,8 @@ module Samagotchi
     # images, no turn id), marked at iteration 0, so a worker killed before
     # the loop's first boundary leaves the prompt and a mark the next one
     # settles. A continue turn (no prompt) is the history, marked.
-    # Every mark of the turn carries +enqueued_id+ (InterruptedTurn's).
+    # Every mark of the turn carries +enqueued_id+ and a participant's
+    # +author+ (InterruptedTurn's).
     # @param prompt [String, nil]
     # @param enqueued_id [String, nil] the input the turn runs
     # @param author [Hash] a participant's prompt's author fields
@@ -179,6 +184,7 @@ module Samagotchi
     def begin_turn(prompt: nil, enqueued_id: nil, author: {})
       @boundaries = 0
       @enqueued_id = enqueued_id.to_s.empty? ? nil : enqueued_id.to_s
+      @author = author[:author]
       @written_at = nil
       @started_at = Time.now.iso8601(3)
       messages = Array(@session.messages).dup
@@ -186,7 +192,7 @@ module Samagotchi
       # stamp (Engine's Turn#wall), which the turn's first boundary saves.
       messages << { role: "user", content: prompt, **author, MessageTime::KEY => MessageTime.iso(MessageTime.now) } unless prompt.to_s.empty?
       @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0,
-                                                                                   enqueued_id: @enqueued_id) }
+                                                                                   enqueued_id: @enqueued_id, author: @author) }
     end
 
     # The turn ended (or never began): the session saves its own messages.
@@ -212,7 +218,7 @@ module Samagotchi
       # forget stub) while a save on another thread serializes this one.
       messages = conversation.map { |message| message.is_a?(Hash) ? message.dup : message } + merged
       marker = InterruptedTurn.new(id: turn_id, started_at: @started_at, at: Time.now.iso8601(3), iteration: @boundaries,
-                                   enqueued_id: @enqueued_id)
+                                   enqueued_id: @enqueued_id, author: @author)
       @session.turn_checkpoint = { messages: messages, marker: marker }
       return false unless due? || !merged.empty?
 

data/lib/samagotchi/version.rb

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