samagotchi 0.107.0 → 0.108.0

data/lib/samagotchi/reply_wait.rb

@@ -221,10 +221,15 @@ module Samagotchi
     # merged): that turn runs (its mark has another id, or none from a
     # worker that writes ids), or, idle, a turn not its ended since the
     # baseline. last_turn or a reply file being its own is never that, nor
-    # an input with a tombstone (a removal's, written before its claim).
+    # an input with a tombstone (a removal's, written before its claim),
+    # nor one whose claimed file is still there: a drain deletes the file
+    # it merges as it reads it, while a turn of its own keeps it until the
+    # turn ends (WorkerInbound#take_input), so a look between that claim
+    # and the turn's running save (idle, an earlier turn's end since the
+    # baseline) doesn't take the earlier turn's reply for it.
     def merged_elsewhere?(session, turn, baseline, session_dir)
       return false if session.last_turn&.enqueued_id == turn || SessionInbox.reply_for(session_dir, turn)
-      return false if SessionInbox.removed?(session_dir, turn)
+      return false if SessionInbox.removed?(session_dir, turn) || SessionInbox.claimed_input?(session_dir, turn)
 
       if session.status == Session::STATUS_RUNNING
         running_id = session.interrupted_turn&.enqueued_id

data/lib/samagotchi/send_command/busy.rb

@@ -40,9 +40,12 @@ module Samagotchi
       # What the user is told, after the session's short id.
       # @param via [ChiInvocation] how its commands are spelled
       def message(via: ChiInvocation::HERE)
-        return "busy: a turn is running; wait or #{via.remote? ? "open it in #{via.web}" : "attach"}" unless error == "waiting"
-
         id = session_id
+        unless error == "waiting"
+          return "busy: a turn is running; --queue runs the message after it, " \
+                 "#{via.command("send --wait #{id}")} waits for it, #{via.attach(id)} shows it"
+        end
+
         # The whole question (its options, its tags) for what a parent may
         # give.
         q = ParentReport.question(question, strategy: strategy)

data/lib/samagotchi/send_command/wait_target.rb

@@ -13,30 +13,35 @@ module Samagotchi
     WaitTarget = Data.define(:turn, :report_turn_id, :queued, :ended_before) do
       def initialize(turn: nil, report_turn_id: nil, queued: false, ended_before: false) = super
 
-      # A --new session's first message. A file-delivered one's own turn
-      # (its id also names the outcome of a session command that runs no
-      # turn); through the Bridge, the next reply.
+      # A --new session's first message: its own turn, the ack's id (a
+      # file-delivered one's also names the outcome of a session command
+      # that runs no turn), so a worker that dies in it and the next one's
+      # settle end the wait (TurnCheckpoint.settled_turn). A message merged
+      # into a turn starting then falls back to that turn's reply
+      # (ReplyWait's turn: without queued:); no id (an older worker), the
+      # next reply.
       # @param delivered [SessionManager::DeliverResult, nil] nil when the
       #   message started the session itself (no delivery)
       def self.first_message(delivered)
         return new unless delivered
 
-        new(turn: delivered.file? ? delivered.enqueued_id : nil, report_turn_id: delivered.enqueued_id)
+        new(turn: delivered.enqueued_id, report_turn_id: delivered.enqueued_id)
       end
 
       # A message to an existing session. --queue: its own turn, the ack's
       # id, also when the turn running at the check ended before it went in
       # (an idle worker's ack says next_step, and the file still runs as
-      # that turn). A file fallback's id names its turn too. Otherwise the
-      # next reply, reported as the turn that was running when it went in
-      # (+running_turn+, ReplyWait.own_turn), or as its own on an idle one.
-      # A plain message the worker queued (its ack says queue: a
-      # participant's review turn was running, which takes no steer) is a
-      # --queue's.
+      # that turn). A file fallback's id names its turn too, and so does a
+      # plain message to an idle session, as #first_message's. Otherwise
+      # (a session left running by a dead worker, the busy check's owner
+      # gone) the next reply, reported as the turn that was running when it
+      # went in (+running_turn+, ReplyWait.own_turn). A plain message the
+      # worker queued (its ack says queue: a participant's review turn was
+      # running, which takes no steer) is a --queue's.
       # @param running [Boolean] the session was running when it went in
       def self.message(delivered, queue:, running:, running_turn:)
         queue ||= delivered.delivery == Delivery::QUEUE
-        turn = delivered.enqueued_id if queue || delivered.file?
+        turn = delivered.enqueued_id if queue || delivered.file? || !running
         report = if queue then turn
                  elsif running then running_turn
                  else delivered.enqueued_id

data/lib/samagotchi/session_inbox.rb

@@ -9,6 +9,7 @@ require_relative "delivery"
 require_relative "log"
 require_relative "session"
 require_relative "steer"
+require_relative "turn_origin"
 
 module Samagotchi
   # A session directory's file inbox and outbox (see SessionManager for the
@@ -221,13 +222,16 @@ module Samagotchi
       Dir.glob(File.join(input_dir, "*.json"))
     end
 
-    # A claimed input file as read: its +prompt+, +origin+ ({client_id:,
-    # enqueued_id:}, nil when it names no sender), whether its turn runs
-    # with the raised iteration limit (+no_interrupt+, --no-interrupt), its
-    # +images+ ({file:, name:} refs), and its +delivery+ ("queue" or nil; a
-    # file without the key is one an older chi wrote, so nil).
+    # A claimed input file as read: its +prompt+, +origin+ (a TurnOrigin
+    # from the file's client_id, enqueued_id and author; nil when it names
+    # no sender), whether its turn runs with the raised iteration limit
+    # (+no_interrupt+, --no-interrupt), its +images+ ({file:, name:} refs),
+    # and its +delivery+ ("queue" or nil; a file without the key is one an
+    # older chi wrote, so nil).
     Input = Data.define(:prompt, :origin, :no_interrupt, :images, :delivery) do
-      def initialize(prompt:, origin: nil, no_interrupt: false, images: [], delivery: nil) = super
+      def initialize(prompt:, origin: nil, no_interrupt: false, images: [], delivery: nil)
+        super(prompt:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:)
+      end
     end
     # A file that doesn't parse, or isn't a JSON object: no prompt.
     UNREADABLE_INPUT = Input.new(prompt: nil)
@@ -239,9 +243,9 @@ module Samagotchi
       return UNREADABLE_INPUT unless data.is_a?(Hash)
 
       # author: only a file that names one (an owner's names none).
-      origin = { client_id: data["client_id"], enqueued_id: data["enqueued_id"], author: data["author"] }.compact
+      origin = TurnOrigin.from(data.slice("client_id", "enqueued_id", "author"))
       images = Array(data["images"]).select { |image| image.is_a?(Hash) }.map { |image| image.transform_keys(&:to_sym) }
-      Input.new(prompt: data["prompt"].to_s, origin: origin.empty? ? nil : origin, no_interrupt: data["no_interrupt"] == true,
+      Input.new(prompt: data["prompt"].to_s, origin: origin, no_interrupt: data["no_interrupt"] == true,
                 images: images, delivery: Delivery.queue?(data["delivery"]) ? Delivery::QUEUE : nil)
     rescue JSON::ParserError
       UNREADABLE_INPUT

data/lib/samagotchi/session_metrics.rb

@@ -19,6 +19,7 @@ require_relative "session_metrics/usage"
 require_relative "session_metrics/side_totals"
 require_relative "side_usage"
 require_relative "steer"
+require_relative "turn_origin"
 
 module Samagotchi
   # SessionMetrics is a persistent, error-isolated collector of per-session
@@ -727,6 +728,7 @@ module Samagotchi
           load_persisted
         end
         @started_at ||= now.iso8601(3)
+        origin = TurnOrigin.from(event[:origin])
         @turn = TurnState.new(
           session_id: @session_id,
           iteration_count: 0,
@@ -766,8 +768,8 @@ module Samagotchi
           gen_switch: false,
           continue: event[:continue] ? true : false,
           resumed: event[:resumed] ? true : false,
-          author: Steer.sender_author(event[:origin].is_a?(Hash) ? event[:origin][:author] : nil),
-          automatic: automatic_origin?(event[:origin]),
+          author: origin&.participant_author,
+          automatic: automatic_origin?(origin),
           id: event[:turn_id] || SecureRandom.uuid,
           started_at: now.iso8601(3),
           started_monotonic: monotonic_time,
@@ -818,11 +820,10 @@ module Samagotchi
       end
     end
 
-    # Whether a turn's +origin+ names a client that is no person's: false
-    # without one (an in-process turn is the owner's).
+    # Whether a turn's +origin+ (a TurnOrigin) names a client that is no
+    # person's: false without one (an in-process turn is the owner's).
     def automatic_origin?(origin)
-      client_id = origin.is_a?(Hash) ? origin[:client_id] : nil
-      !client_id.nil? && !ClientId.human?(client_id)
+      !origin&.client_id.nil? && !origin.human?
     end
 
     # The running turn's record so far, as end_turn would make it for a

data/lib/samagotchi/session_participants.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "steer"
+
 module Samagotchi
   # Loaded only when a session is read: it brings Web::Grants (and Rack).
   autoload :Participants, File.expand_path("participants", __dir__)
@@ -38,7 +40,7 @@ module Samagotchi
       return nil unless Steer.participant_author?(author)
 
       refresh!(session) if session && session.id != @session_id
-      id = author.to_s.delete_prefix("p:")
+      id = Steer.participant_id(author)
       entry = @entries.find { |e| e.id == id } || (@entries = read).find { |e| e.id == id }
       entry&.name
     end

data/lib/samagotchi/steer.rb

@@ -128,6 +128,9 @@ module Samagotchi
     PARTICIPANT_SOURCE = "participant"
     # The owner's author, when one is written out; absent means the same.
     OWNER_AUTHOR = "owner"
+    # A participant's author: this prefix, then its id (Web::Grants'
+    # grant id), "p:<id>" (#author_for, #participant_id).
+    PARTICIPANT_PREFIX = "p:"
     # A participant's message's keys, which every message copy keeps.
     AUTHOR_KEYS = %i[author author_name].freeze
 
@@ -187,7 +190,7 @@ module Samagotchi
     # again (ParticipantName), or the participant's id when it has none.
     def review_header(message)
       name = ParticipantName.clean(message[:author_name] || message["author_name"])
-      name = ParticipantName.clean((message[:author] || message["author"]).to_s.delete_prefix("p:")) if name.empty?
+      name = ParticipantName.clean(participant_id(message[:author] || message["author"])) if name.empty?
       format(REVIEW_HEADER, name.empty? ? "a participant" : name)
     end
 
@@ -219,6 +222,13 @@ module Samagotchi
     # +author+ when it is a participant's, else nil (the owner).
     def sender_author(author) = participant_author?(author) ? author.to_s : nil
 
+    # The author a participant's turns and messages carry: "p:<id>".
+    def author_for(participant_id) = "#{PARTICIPANT_PREFIX}#{participant_id}"
+
+    # The participant id in +author+ ("p:<id>" → "<id>"); a string without
+    # the prefix as it is ("" for nil).
+    def participant_id(author) = author.to_s.delete_prefix(PARTICIPANT_PREFIX)
+
     # The text a steer or merged input goes out as: its header, a newline,
     # then +text+ (the message's content by default). Other messages: +text+.
     def wire_text(message, text = (message[:content] || message["content"]).to_s)

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -22,6 +22,7 @@ require_relative "../delivery"
 require_relative "../log"
 require_relative "../context_note"
 require_relative "../steer"
+require_relative "../turn_origin"
 require_relative "../model_profile"
 require_relative "../output_formatter"
 require_relative "../session_commands"
@@ -317,7 +318,7 @@ module Samagotchi
         when :input_merged
           merged_own_prompts(event)
           # A delegate's report: a child's state changed.
-          refresh_children if Array(event[:origins]).any? { |origin| report_origin?(origin) }
+          refresh_children if Array(event[:origins]).any? { |origin| report_origin?(origin_of(origin)) }
         when :question_requested
           # Nothing is left to answer it with.
           return unanswered_question(event[:pending_question]) if @input_ended
@@ -973,7 +974,7 @@ module Samagotchi
       def own_turn_ended(event)
         return unless @wait_at_eof
 
-        id = (event[:origin] || {})[:enqueued_id]
+        id = origin_of(event[:origin]).enqueued_id
         ours = @open_ids.include?(id) || !@merged_ids.empty?
         @own_failed = true if ours && event[:type] == :turn_failed
         @own_empty = true if ours && event[:type] == :turn_completed && event.dig(:turn_summary, :empty_answer)
@@ -986,9 +987,10 @@ module Samagotchi
 
       # Ours merged into the running turn: they end with it.
       def merged_own_prompts(event)
-        Array(event[:origins]).each do |origin|
-          id = origin[:enqueued_id]
-          @merged_ids << id if own?(origin[:client_id]) && @open_ids.include?(id)
+        Array(event[:origins]).each do |value|
+          origin = origin_of(value)
+          id = origin.enqueued_id
+          @merged_ids << id if own?(origin.client_id) && @open_ids.include?(id)
         end
         nil
       end
@@ -1188,8 +1190,8 @@ module Samagotchi
       # The worker rolled a failed turn back and handed its prompt back: ours
       # goes back into the input, as the REPL restores it for a retry.
       def restore_prompt(event)
-        origin = event[:origin] || {}
-        return unless own?(origin[:client_id]) && @sent_ids.include?(origin[:enqueued_id])
+        origin = origin_of(event[:origin])
+        return unless own?(origin.client_id) && @sent_ids.include?(origin.enqueued_id)
         # Lines from a pipe: nobody to retry it (the REPL's rule).
         return if @wait_at_eof
 
@@ -1342,7 +1344,7 @@ module Samagotchi
           next if own?(entry[:client_id])
 
           @shown_enqueued << entry[:enqueued_id]
-          @screen.commit("queued #{prompt_line(entry[:client_id], entry[:prompt], **author_of(entry))}")
+          @screen.commit("queued #{prompt_line(entry[:client_id], entry[:prompt], **author_of(entry[:author]))}")
         end
         # Commands waiting for the turn's end (their command_ran prints no
         # line); a resync prints only the ones it hadn't shown.
@@ -1606,9 +1608,9 @@ module Samagotchi
         return unless turn
 
         continues = turn[:prompt].nil?
-        unless continues && reminder_origin?(turn[:origin] || {})
-          origin = turn[:origin] || {}
-          @screen.commit(prompt_line(origin[:client_id], turn[:prompt] || continuing_text(origin), **author_of(origin)))
+        origin = origin_of(turn[:origin])
+        unless continues && reminder_origin?(origin)
+          @screen.commit(prompt_line(origin.client_id, turn[:prompt] || continuing_text(origin), **author_of(origin.author)))
         end
         tail = nil
         lane = :writing
@@ -1657,7 +1659,7 @@ module Samagotchi
         return if own?(event[:client_id])
 
         @shown_enqueued << event[:enqueued_id]
-        line = prompt_line(event[:client_id], event[:prompt], **author_of(event))
+        line = prompt_line(event[:client_id], event[:prompt], **author_of(event[:author]))
         @screen.commit(event[:delivery] == Delivery::QUEUE ? "#{line} #{QUEUED_NOTE}" : line)
       end
 
@@ -1684,18 +1686,18 @@ module Samagotchi
       def start_turn(event)
         @running = true
         @joined_mid_turn = false
-        origin = event[:origin] || {}
-        @my_queued.delete(origin[:enqueued_id])
+        origin = origin_of(event[:origin])
+        @my_queued.delete(origin.enqueued_id)
         if event[:prompt].nil?
           # A continue turn (after the offer's yes) has no prompt to show; a
           # reminder turn shows its reminders (:reminder_injected).
           # A turn run for delegate reports shows them as they merge; one
           # an attached context change started, its label (the note is above).
           unless reminder_origin?(origin) || report_origin?(origin)
-            @screen.commit(prompt_line(origin[:client_id], continuing_text(origin), **author_of(origin)))
+            @screen.commit(prompt_line(origin.client_id, continuing_text(origin), **author_of(origin.author)))
           end
-        elsif !(own?(origin[:client_id]) || @shown_enqueued.include?(origin[:enqueued_id]))
-          @screen.commit(prompt_line(origin[:client_id], event[:prompt], **author_of(origin)))
+        elsif !(own?(origin.client_id) || @shown_enqueued.include?(origin.enqueued_id))
+          @screen.commit(prompt_line(origin.client_id, event[:prompt], **author_of(origin.author)))
         end
         # The own-send echo already names an image-only prompt; another
         # client's prompt line does too, here or at its enqueue.
@@ -1755,14 +1757,14 @@ module Samagotchi
       end
 
       def learn_participants(rows)
-        Array(rows).each { |row| @participant_names["p:#{row[:id]}"] = row[:name] if row.is_a?(Hash) && row[:id] }
+        Array(rows).each { |row| @participant_names[Steer.author_for(row[:id])] = row[:name] if row.is_a?(Hash) && row[:id] }
       end
 
-      # The prompt line's author keywords for an event, an origin or a
-      # queued row ({author: "p:<id>"}): their name as the worker named
+      # The prompt line's author keywords for the +author+ of an event, an
+      # origin or a queued row ("p:<id>"): their name as the worker named
       # them; {} for the owner's.
-      def author_of(row)
-        author = Steer.sender_author(row[:author]) or return {}
+      def author_of(author)
+        author = Steer.sender_author(author) or return {}
 
         { author: author, author_name: @participant_names[author] }
       end
@@ -1784,10 +1786,12 @@ module Samagotchi
         @default_model_name ||= @link.default_model_name
       end
 
-      def reminder_origin?(origin) = origin[:client_id].to_s.start_with?(ClientId::SYSTEM_PREFIX)
-      def report_origin?(origin) = ClientId.origin(origin[:client_id]) == "delegate_report"
-      def context_origin?(origin) = ClientId.origin(origin[:client_id]) == "context"
-      def task_origin?(origin) = ClientId.origin(origin[:client_id]) == "task"
+      # An event's origin (its wire Hash) as a TurnOrigin, NONE for none.
+      def origin_of(value) = TurnOrigin.of(value)
+      def reminder_origin?(origin) = origin.client_id.to_s.start_with?(ClientId::SYSTEM_PREFIX)
+      def report_origin?(origin) = origin.source == "delegate_report"
+      def context_origin?(origin) = origin.source == "context"
+      def task_origin?(origin) = origin.source == "task"
       # A turn with no prompt: "(continuing)"; a context wake's or a task
       # finish wake's label alone.
       def continuing_text(origin) = context_origin?(origin) || task_origin?(origin) ? nil : "(continuing)"

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -251,7 +251,7 @@ module Samagotchi
       def participant_prefix(author, name)
         return "" unless Steer.participant_author?(author)
 
-        id = author.to_s.delete_prefix("p:")
+        id = Steer.participant_id(author)
         "#{paint("#{participant_display_name(id, name)} ▸", participant_colour(id))} "
       end
 
@@ -632,7 +632,7 @@ module Samagotchi
         return nil unless rows.is_a?(Hash) && !rows.empty?
 
         rows.map do |author, row|
-          name = row[:name].to_s.empty? ? author.to_s.delete_prefix("p:") : row[:name]
+          name = row[:name].to_s.empty? ? Steer.participant_id(author) : row[:name]
           turns = row[:turns].to_i
           format("%<name>s $%<cost>.2f (%<turns>d turn%<s>s)", name: name, cost: row[:cost].to_f, turns: turns,
                                                                s: turns == 1 ? "" : "s")

data/lib/samagotchi/terminal_ui/one_shot_sink.rb

@@ -15,7 +15,10 @@ module Samagotchi
     # a failed request (:generation_retrying). And the hooks' notices
     # (:hook_notice): one during the turn as it comes, one the after_turn
     # hooks give (after :turn_completed; source-links' `sources:`) kept for
-    # #flush, which the caller runs after it has printed the answer.
+    # #flush, which the caller runs after it has printed the answer. And
+    # the load warnings the first turn announces (:guardrail_warning: the
+    # guardrails, the plugins, an orphaned project memory folder), as the
+    # REPL's "<label>> …" lines.
     class OneShotSink
       include Formatting
 
@@ -33,6 +36,7 @@ module Samagotchi
         when :llm_context_edited then line(format_llm_context_line(event))
         when :generation_retrying then line(format_generation_retry_line(event))
         when :turn_completed, :turn_canceled then @turn_over = true
+        when :guardrail_warning then line(EventRenderer.load_warning_line(event))
         when :hook_notice
           text = EventRenderer.hook_notice_line(event)
           @turn_over ? @held << text : line(text)

data/lib/samagotchi/tools/memory.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "digest"
 require "date"
 require_relative "../atomic_file"
+require_relative "../memory_orphans"
 require_relative "../memory_paths"
 require_relative "../model_match"
 
@@ -30,9 +31,9 @@ module Samagotchi
         scope = normalize_scope(scope)
 
         if entry_name.empty?
-          return scoped_index(scope) if scope
+          return scoped_index(scope) + (scope == "project" ? orphan_hint : "") if scope
 
-          project = scoped_index("project")
+          project = scoped_index("project") + orphan_hint
           system = scoped_index("system")
           return [
             "Project memories:",
@@ -79,19 +80,25 @@ module Samagotchi
           missing << name unless found
         end
 
-        if results.empty? && !missing.empty?
-          "Error: memory not found: #{missing.join(", ")}"
-        elsif missing.empty?
-          results.join(SEPARATOR)
-        else
-          results.join(SEPARATOR) + SEPARATOR + "Error: memory not found: #{missing.join(", ")}"
-        end
+        return results.join(SEPARATOR) if missing.empty?
+
+        # The hint goes after the first line: WorkingSet reads the missing
+        # names off it (WorkingSet::MISSING) and a failure off its "Error".
+        miss = "Error: memory not found: #{missing.join(", ")}#{orphan_hint if resolved_scopes.include?("project")}"
+        results.empty? ? miss : results.join(SEPARATOR) + SEPARATOR + miss
       rescue Errno::ENOENT => e
         "Error: #{e.message}"
       rescue StandardError => e
         "Error: #{e.message}"
       end
 
+      # "\nHint: …" when this project's memory folder looks orphaned
+      # (MemoryOrphans), else "".
+      def self.orphan_hint
+        message = MemoryOrphans.message
+        message ? "\nHint: #{message}" : ""
+      end
+
       # A memory is a flat file in its scope dir: a name with a path in it
       # ("../../x") would read or write outside the memories.
       def self.invalid_name?(name)

data/lib/samagotchi/turn_origin.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "client_id"
+require_relative "steer"
+
+module Samagotchi
+  # Who queued a turn: the client that sent it (+client_id+, ClientId), the
+  # input file's id (+enqueued_id+, the reply's and the events' key) and,
+  # for a participant's, its +author+ ("p:<id>"; none for the owner's).
+  # Engine#run_turn's, the Worker's and GuardrailWiring's. On the wire (a
+  # turn's boundary events, Bridge SSE, the inbox JSON's own fields) an
+  # origin stays the Hash it always was: #to_h writes it, .from reads it
+  # back, so a value that crosses a boundary is turned there, once.
+  TurnOrigin = Data.define(:client_id, :enqueued_id, :author) do
+    def initialize(client_id: nil, enqueued_id: nil, author: nil) = super
+
+    # An origin from what a boundary carries: a TurnOrigin as it is, a Hash
+    # (symbol or string keys: an event, an SSE line, a spec) as one; nil for
+    # nil, an empty Hash and anything else (no sender named).
+    # @return [TurnOrigin, nil]
+    def self.from(value)
+      return value if value.is_a?(TurnOrigin)
+      return nil unless value.is_a?(Hash)
+
+      field = ->(key) { value.key?(key) ? value[key] : value[key.to_s] }
+      origin = new(client_id: field.call(:client_id), enqueued_id: field.call(:enqueued_id), author: field.call(:author))
+      origin.empty? ? nil : origin
+    end
+
+    # An origin either way: .from's, or NONE when the value names no
+    # sender (nil, {}). In-process an owner's turn has NONE, never nil.
+    # @return [TurnOrigin]
+    def self.of(value) = from(value) || self::NONE
+
+    # Whether it names no sender (NONE): its wire form is left out.
+    def empty? = to_h.empty?
+
+    # The wire form where a field may carry no origin: #to_h, nil for NONE
+    # (an event's origin:, a hook's context).
+    # @return [Hash, nil]
+    def wire = empty? ? nil : to_h
+
+    # Whether a participant queued the turn (Steer.participant_author?: any
+    # author but none or the owner's).
+    def participant? = Steer.participant_author?(author)
+
+    # The author when a participant's (Steer.sender_author), else nil.
+    def participant_author = Steer.sender_author(author)
+
+    # The participant's id (Steer.participant_id: its author without "p:"),
+    # nil for the owner's.
+    def participant_id = participant_author && Steer.participant_id(participant_author)
+
+    # What sent the turn, by its client (ClientId.origin): "client",
+    # "reminder", "delegate", "review"...
+    def source = ClientId.origin(client_id)
+
+    # Whether a human sent the turn (ClientId.human?: a missing client is).
+    def human? = ClientId.human?(client_id)
+
+    # The wire form: only the fields set, as a turn's origin always went out.
+    def to_h = super.compact
+  end
+
+  # No sender named: an owner's turn with no client, run_turn's default
+  # (TurnOrigin.of).
+  TurnOrigin::NONE = TurnOrigin.new
+end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -57,6 +57,7 @@ require_relative "session_summary"
 require_relative "session_access_routes"
 require_relative "principal"
 require_relative "participant_access"
+require_relative "participants_admin"
 require_relative "participant_review"
 require_relative "../log"
 require_relative "../paths"
@@ -76,6 +77,7 @@ module Samagotchi
       include RedactedInspect
       include SessionAccessRoutes
       include ParticipantAccess
+      include ParticipantsAdmin
       include ParticipantReview
 
       DEFAULT_HOST = BridgeClient::HOST

data/lib/samagotchi/web/grants.rb

@@ -3,6 +3,7 @@
 require "digest"
 require "fileutils"
 require "json"
+require_relative "../steer"
 require "securerandom"
 require "time"
 require "rack/utils"
@@ -104,7 +105,7 @@ module Samagotchi
         def queue_limit = queue.is_a?(Integer) ? queue : Grants.default_queue
 
         # The author a participant's turn carries (Principal#author).
-        def author = "p:#{id}"
+        def author = Steer.author_for(id)
 
         # :active, :revoked or :expired at +now+ (a Time).
         def state(now)