samagotchi 0.104.0 → 0.106.0

data/lib/samagotchi/reply_wait/poll.rb

@@ -3,6 +3,8 @@
 require_relative "../session"
 require_relative "../session_inbox"
 require_relative "../turn_checkpoint"
+require_relative "../continue_offer"
+require_relative "../steer"
 
 module Samagotchi
   module ReplyWait
@@ -70,7 +72,7 @@ module Samagotchi
 
         note_own_running(session)
         follow_merge(session)
-        reply(session) || settled_turn(session) || status_end(session) || question(session) || canceled ||
+        reply(session) || settled_turn(session) || status_end(session) || question(session) || held(session) || canceled ||
           ended_before_reply(session) || ended_before_turn(session) || turn_end(session) || owner_gone(session) ||
           timed_out
       end
@@ -78,8 +80,9 @@ module Samagotchi
       def look_at_input
         return unless @turn && !@claimed
 
-        waiting = SessionInbox.waiting_input(@session_dir, @turn)
-        @own_turn_input ||= waiting == :turn_end
+        waiting = SessionInbox.waiting_input_data(@session_dir, @turn)
+        @own_turn_input ||= !waiting.nil? && SessionInbox.turn_end_data?(waiting)
+        @participant_input ||= !waiting.nil? && Steer.participant_author?(waiting["author"])
         @claimed = waiting.nil?
       end
 
@@ -161,6 +164,18 @@ module Samagotchi
         Result.new(status: :waiting_for_answer, question: pending, session: session)
       end
 
+      # A participant's turn its worker holds while the owner's Continue
+      # offer stands (Worker#run_input_files): it waits for the owner's
+      # answer to that question, whenever it was asked (the baseline's
+      # question too). An owner's turn is never held: it drops the offer.
+      def held(session)
+        pending = session.pending_question
+        return nil unless @participant_input && !@claimed && pending&.kind.to_s == ContinueOffer::KIND &&
+                          session.waiting_question(live: SessionManager.worker_live?(@id, state_dir: @state_dir))
+
+        Result.new(status: :waiting_for_answer, question: pending, session: session)
+      end
+
       def canceled = @cancelled.call ? Result.new(status: :canceled) : nil
 
       # The turn that ended before this wait (ended_before: chi send --wait

data/lib/samagotchi/run_options.rb

@@ -146,7 +146,7 @@ module Samagotchi
                  chi context <add|push|ls|show|refresh|rm|mute|unmute>   live external text attached to sessions
                  chi send [-m TEXT] ID...|--new   a message into sessions, as if typed there
                  chi answer ID --question QID --option N   answer a question a session waits on
-                 chi share ID --name NAME | ls [ID] | revoke ID [P]|--all   participants who review a session
+                 chi share ID --name NAME | ls [ID] | cap ID P D | revoke ID [P]|--all   participants who review a session
                  chi memory <ls|rm> [--scope project|system]   the memories; rm moves one to the bundle trash
                  chi bundle <install|upgrade|uninstall|status|diff|list|build|trash|new|test|check|try>
                  chi desktop <install|upgrade|uninstall|status>   macOS "Send to chi" helper

data/lib/samagotchi/send_command.rb

@@ -143,11 +143,12 @@ module Samagotchi
                     status answered (text), question (question,
                     answer_with), turn_id when known, running, or failed, canceled,
                     limit, no_answer, error, worker_gone, stopped,
-                    command (detail); with --cut or --queue also
+                    command, waiting_for_owner (detail); with --cut or --queue also
                     delivery (what the worker applied: next_step, cut,
                     queue), with --cut also cut (now, waits, off)
         Exit with --wait: 0 answered, 1 failed or gone, 2 usage, 3 a
-        question waits, 4 still running (--timeout), 130 Ctrl-C.
+        question waits (or the owner, for a participant's token), 4
+        still running (--timeout), 130 Ctrl-C.
         Sessions on this machine, or another's: chi --remote NAME send …
         (chi remote). Answers show in the attached TUI or web page, not
         here.
@@ -259,6 +260,7 @@ module Samagotchi
     def run_parsed(options)
       # With --wait stdout is the answer alone.
       @info = options[:wait] ? @stderr : @stdout
+      @waiting = options[:wait] == true
       @cut = options[:cut] == true
       @queue = options[:queue] == true
       prompt = compose(utf8(read_stdin), utf8(options[:message]))
@@ -581,6 +583,8 @@ module Samagotchi
     # @return [Integer] the exit status
     def run_wait(prompt, options)
       id = resolve(options[:ids].first) or return 1
+      return run_participant_wait(id, prompt, options) if @access.participant?
+
       # Local: one read for the check and the baseline; remotely the
       # server's wait prepare route reads both (Busy's words).
       session = @access.show(id) unless @access.remote?
@@ -598,6 +602,27 @@ module Samagotchi
       wait_for_reply(id, cursor: start.cursor, baseline: start.baseline, timeout: options[:timeout], **target.to_h)
     end
 
+    # A participant's --wait -m (a review turn through chi --remote with
+    # their token): their message always runs as a queued turn of its own
+    # (chi web's review turns), so a running turn doesn't refuse it and
+    # there is no busy check (the owner's route, refused to them). Their
+    # wait routes take only a turn of theirs: the wait is on the one just
+    # queued, as --wait --turn T.
+    # @return [Integer] the exit status
+    def run_participant_wait(id, prompt, options)
+      return 1 unless deliver(id, prompt)
+
+      turn = @delivered.enqueued_id.to_s
+      if turn.empty?
+        error_line("chi send: #{id[0, 8]}: the review turn's id didn't come back; chi --remote … send --wait --turn T waits once you have it")
+        return 1
+      end
+      start = @access.prepare_wait(id, turn: turn)
+      wait_for_reply(id, cursor: start.cursor, baseline: start.baseline, timeout: options[:timeout],
+                         owner_grace: start.live ? self.class::WORKER_GONE_AFTER : nil,
+                         **WaitTarget.after(start, requested: turn).to_h)
+    end
+
     # --wait with no message: the session's next reply, sending nothing,
     # so an agent can go back to waiting after exit 3 or 130. A running
     # turn is fine here (nothing joins its queue); a question pending now
@@ -765,7 +790,10 @@ module Samagotchi
       # (next_step for an idle session) and a cut's outcome.
       @sent_delivery = result.delivery || delivery
       @sent_cut = result.cut
-      @info.puts("#{short}  sent#{with_images}#{delivery_note(result, delivery: delivery, running: running, owner: owner)}")
+      note = if @access.participant? then participant_note(id, result)
+             else delivery_note(result, delivery: delivery, running: running, owner: owner)
+             end
+      @info.puts("#{short}  sent#{with_images}#{note}")
       true
     rescue SessionManager::OwnedByTUI
       @info.puts("#{short}  refused: it is open in a chi REPL; messages need attached mode")
@@ -801,6 +829,16 @@ module Samagotchi
       " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym, result.cut_after)}"
     end
 
+    # A participant's message: queued as a review turn of its own (chi
+    # web's), its id the one their wait takes.
+    def participant_note(id, result)
+      turn = result.enqueued_id.to_s
+      return " (queued as a review turn)" if turn.empty?
+      return " (queued as review turn #{turn})" if @waiting
+
+      " (queued as review turn #{turn}; #{@access.invocation.command("send --wait --turn #{turn} #{id}")} waits for its reply)"
+    end
+
     # A --queue, worded from the Bridge's ack: queue when a turn ran as it
     # went in (one another client started too), next_step when none did
     # (it runs now). The input file (no Bridge) carries the queue to

data/lib/samagotchi/session_access/contract.rb

@@ -122,6 +122,8 @@ module Samagotchi
         "share --name" => SUPPORTED,
         "share --agent" => SUPPORTED,
         "share --expires" => SUPPORTED,
+        "share --cap" => SUPPORTED,
+        "share cap" => SUPPORTED,
         "share ls" => SUPPORTED,
         "share ls --format" => SUPPORTED,
         "share revoke" => SUPPORTED,

data/lib/samagotchi/session_access/local.rb

@@ -17,6 +17,7 @@ require_relative "../participants"
 require_relative "../config"
 require_relative "../web/grants"
 require_relative "../web/info_probe"
+require_relative "../web/running"
 
 module Samagotchi
   # Loaded on first use: SessionManager and its ~80 files only when a
@@ -38,6 +39,9 @@ module Samagotchi
 
       def remote? = false
 
+      # This machine's sessions are the owner's.
+      def participant? = false
+
       # The printed commands' spelling: this machine's chi.
       # @return [ChiInvocation]
       def invocation = ChiInvocation::HERE
@@ -339,13 +343,14 @@ module Samagotchi
         grants.list(session_id: id).map { |grant| ParticipantView.from_h(grant.public_h(grants.now)) }
       end
 
-      # The link names this machine's chi web: its LAN address when one
-      # runs on the LAN (web.port), else 127.0.0.1 (+lan+ false).
+      # The link names this machine's chi web: its LAN address and port
+      # when one runs on the LAN (the port it recorded, else web.port),
+      # else 127.0.0.1 (+lan+ false).
       # @return [Invitation]
       # @raise [ArgumentError] no such session
       # @raise [BadRequest] a bad name, kind or ttl, an archived session
-      def invite(id, name:, kind:, ttl: nil)
-        issued = Participants.invite(grants, session_id: id, name: name, kind: kind, ttl: ttl, state_dir: state_dir!)
+      def invite(id, name:, kind:, ttl: nil, cap: nil)
+        issued = Participants.invite(grants, session_id: id, name: name, kind: kind, ttl: ttl, cap: cap, state_dir: state_dir!)
         ip, port = local_web
         Invitation.new(participant: ParticipantView.from_h(issued.grant.public_h(grants.now)), token: issued.token,
                        link: "http://#{ip || "127.0.0.1"}:#{port}/?token=#{issued.token}#s=#{id}", lan: !ip.nil?)
@@ -359,6 +364,17 @@ module Samagotchi
                     .map { |grant| ParticipantView.from_h(grant.public_h(grants.now)) }
       end
 
+      # @return [ParticipantView] the participant with their new cap
+      # @raise [BadRequest] a cap out of range, or no such active participant
+      def set_participant_cap(id, participant:, cap:)
+        grant = Participants.set_cap(grants, session_id: id, id: participant, cap: cap, state_dir: state_dir!)
+        raise BadRequest.new(Participants.no_participant(participant, id), code: "invalid_participant") unless grant
+
+        ParticipantView.from_h(grant.public_h(grants.now))
+      rescue Web::Grants::Invalid => e
+        raise BadRequest.new(e.message, code: "invalid_participant")
+      end
+
       private
 
       def grants = @grants ||= Web::Grants.new(Web::Grants.path(state_dir: state_dir!))
@@ -367,12 +383,18 @@ module Samagotchi
       WEB_PORT = 4567
       LOCAL_PROBE_TIMEOUT = 1.0
 
-      # [LAN ip or nil, port] of this machine's chi web (GET /api/info).
+      # [LAN ip or nil, port] of this machine's chi web (GET /api/info):
+      # the port the running one recorded (Web::Running) when a chi web
+      # answers there, else config's web.port.
       def local_web
-        port = Config.get("web.port").to_s.to_i
-        port = WEB_PORT unless port.positive?
-        info = Web::InfoProbe.call("127.0.0.1", port, timeout: LOCAL_PROBE_TIMEOUT)
-        [info.is_a?(Hash) ? info["lan"] : nil, port]
+        configured = Config.get("web.port").to_s.to_i
+        configured = WEB_PORT unless configured.positive?
+        recorded = Web::Running.port(path: Web::Running.path(state_dir: state_dir!))
+        [recorded, configured].compact.uniq.each do |port|
+          info = Web::InfoProbe.call("127.0.0.1", port, timeout: LOCAL_PROBE_TIMEOUT)
+          return [info["lan"], port] if info.is_a?(Hash)
+        end
+        [nil, configured]
       end
 
       def dir = @state_dir ? { state_dir: @state_dir } : {}

data/lib/samagotchi/session_access/remote.rb

@@ -58,6 +58,14 @@ module Samagotchi
       def remote? = true
       def name = @entry.name
 
+      # Web::Grants::PREFIX, without loading chi web.
+      PARTICIPANT_PREFIX = "chp_"
+
+      # Whether the token is a participant's (chi share's link), not the
+      # owner's: their turns are queued review turns, their waits take only
+      # a turn of theirs.
+      def participant? = @entry.token.to_s.start_with?(PARTICIPANT_PREFIX)
+
       # The printed commands' spelling: chi --remote NAME.
       # @return [ChiInvocation]
       def invocation = ChiInvocation.new(remote: name)
@@ -245,8 +253,8 @@ module Samagotchi
       # @param ttl [Integer, nil] seconds; nil: the grant's default
       # @return [Invitation]
       # @raise [BadRequest] a bad name, kind or ttl, an archived session
-      def invite(id, name:, kind:, ttl: nil)
-        reply = request(:post, "#{session_path(id)}/participants", body: { name: name, kind: kind, ttl: ttl }.compact)
+      def invite(id, name:, kind:, ttl: nil, cap: nil)
+        reply = request(:post, "#{session_path(id)}/participants", body: { name: name, kind: kind, ttl: ttl, cap: cap }.compact)
         raise_refusal(reply) unless reply.status == 201
 
         json = reply.json
@@ -265,6 +273,15 @@ module Samagotchi
         Array(reply.json["revoked"]).map { |row| ParticipantView.from_h(row) }
       end
 
+      # @return [ParticipantView] the participant with their new cap
+      # @raise [BadRequest] a cap out of range, or no such active participant
+      def set_participant_cap(id, participant:, cap:)
+        reply = request(:post, "#{session_path(id)}/participants/#{participant}/cap", body: { cap: cap })
+        raise_refusal(reply) unless reply.status == 200
+
+        ParticipantView.from_h(reply.json.fetch("participant"))
+      end
+
       def note(id, text:, source:)
         reply = request(:post, "#{session_path(id)}/notes", body: { text: text, source: source })
         json = reply.json.is_a?(Hash) ? reply.json : {}

data/lib/samagotchi/session_access/web_bridge_client.rb

@@ -92,9 +92,11 @@ module Samagotchi
       def port = nil
 
       # POST …/turn. history: false (chi web's prompt history is that
-      # machine's page's).
+      # machine's page's). +author+ is never sent: the remote chi web stamps
+      # a turn's author from the token this client holds (Web::Principal),
+      # never from the body.
       # @return [BridgeClient::Response]
-      def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil, delivery: nil)
+      def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil, delivery: nil, author: nil)
         body = { prompt: prompt, client_id: client_id, history: false }
         body[:no_interrupt] = true if no_interrupt
         body[:images] = images if images && !images.empty?

data/lib/samagotchi/session_access.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "participant_messages"
+
 module Samagotchi
   # The seam between chi's session commands (chi send, answer, note,
   # session-scope context, sessions list/stop/restart/archive/unarchive/
@@ -60,13 +62,13 @@ module Samagotchi
     # queue up to their limit.
     class TooManyTurns < RemoteFailed
       CODE = "too_many_turns"
-      def initialize(label) = super("#{label}: this participant has too many turns waiting: wait for one to finish")
+      def initialize(label) = super("#{label}: #{ParticipantMessages::TOO_MANY_TURNS}")
     end
 
     # 429 cap_reached (P3b): the participant's grant spent its cap.
     class CapReached < RemoteFailed
       CODE = "cap_reached"
-      def initialize(label) = super("#{label}: this participant's spending cap is reached: ask the session's owner to raise it")
+      def initialize(label) = super("#{label}: #{ParticipantMessages::CAP_REACHED}")
     end
 
     # A remote's chi web refused a request for a reason this machine checks
@@ -91,8 +93,9 @@ module Samagotchi
     # One participant's grant as chi share ls shows it
     # (Web::Grants::Grant#public_h): never its token or digest. +state+
     # "active", "revoked" or "expired".
+    # +cap+ dollars and +queue+ turns (nil from a chi web before them).
     ParticipantView = Data.define(:id, :session_id, :kind, :name, :role, :created_at, :expires_at, :revoked_at,
-                                  :revoked_by, :last_used_at, :state) do
+                                  :revoked_by, :last_used_at, :state, :cap, :queue) do
       def self.from_h(hash) = new(**members.to_h { |key| [key, hash[key] || hash[key.to_s]] })
     end
 

data/lib/samagotchi/session_commands.rb

@@ -158,6 +158,12 @@ module Samagotchi
       # runs (the worker's POST turn/dequeue); the web has × on the bubble.
       registry.register("/unqueue", "remove your newest queued message before it runs", local: true, uis: [:attached],
                                                                                           match: ->(text) { text.casecmp?("/unqueue") })
+      # chi share for the attached session (TerminalUI::ParticipantCommands):
+      # a participant's turns run on its worker, so the REPL points there.
+      registry.register("/share", "invite someone to review this session (/share NAME [--agent] [--expires 3d] [--cap 2])",
+                        local: true, uis: [:attached], match: ->(text) { text.match?(%r{\A/share(?:\s.*)?\z}i) })
+      registry.register("/participants", "list this session's participants (revoke [P], cap P DOLLARS)",
+                        local: true, uis: [:attached], match: ->(text) { text.match?(%r{\A/participants(?:\s.*)?\z}i) })
       registry
     end
 

data/lib/samagotchi/session_inbox.rb

@@ -8,6 +8,7 @@ require_relative "atomic_file"
 require_relative "delivery"
 require_relative "log"
 require_relative "session"
+require_relative "steer"
 
 module Samagotchi
   # A session directory's file inbox and outbox (see SessionManager for the
@@ -248,31 +249,56 @@ module Samagotchi
 
     # Whether a mid-turn drain leaves this unclaimed input file for a turn
     # of its own instead of merging it at a step boundary: a queued message
-    # (`delivery: queue`) or an image message (steering merges text only).
+    # (`delivery: queue`), an image message (steering merges text only), or
+    # a participant's, whatever its delivery says: theirs always runs as its
+    # own turn, never inside another author's (D6; chi web queues it, and
+    # this is the worker's own layer).
     # The drain skips such a file without stopping at it, so a later text
     # line still merges; the drain's file filter reads this one predicate,
     # so what a boundary leaves changes in one place.
     def self.waits_for_turn_end?(input_file)
       data = JSON.parse(File.read(input_file))
-      data.is_a?(Hash) && (Array(data["images"]).any? || Delivery.queue?(data["delivery"]))
+      data.is_a?(Hash) && turn_end_data?(data)
     rescue JSON::ParserError, SystemCallError
       false
     end
 
+    # Whether an unclaimed input file may be a participant's (it names a
+    # participant author): what the worker holds while the owner's Continue
+    # offer stands (Worker#run_input_files). An unreadable file counts:
+    # holding it costs nothing (it runs no turn), running it unread could.
+    def self.participant_input?(input_file)
+      data = JSON.parse(File.read(input_file))
+      !data.is_a?(Hash) || Steer.participant_author?(data["author"])
+    rescue JSON::ParserError, SystemCallError
+      true
+    end
+
+    # A parsed input file's #waits_for_turn_end?.
+    def self.turn_end_data?(data)
+      Array(data["images"]).any? || Delivery.queue?(data["delivery"]) || Steer.participant_author?(data["author"])
+    end
+
     # How the unclaimed input file carrying +enqueued_id+ waits: :turn_end
     # (a queue or an image message: it runs as a turn of its own, never
     # merged, #waits_for_turn_end?), :merges (a running turn's drain may
     # take it as a steer), or nil when none waits.
     # @return [Symbol, nil]
     def self.waiting_input(session_dir, enqueued_id)
+      data = waiting_input_data(session_dir, enqueued_id) or return nil
+      turn_end_data?(data) ? :turn_end : :merges
+    end
+
+    # The unclaimed input file carrying +enqueued_id+, as parsed; nil when
+    # none waits.
+    # @return [Hash, nil]
+    def self.waiting_input_data(session_dir, enqueued_id)
       id = enqueued_id.to_s
       return nil if id.empty?
 
       find_new_input_files(session_dir).each do |file|
         data = JSON.parse(File.read(file))
-        next unless data.is_a?(Hash) && data["enqueued_id"] == id
-
-        return Array(data["images"]).any? || Delivery.queue?(data["delivery"]) ? :turn_end : :merges
+        return data if data.is_a?(Hash) && data["enqueued_id"] == id
       rescue JSON::ParserError, SystemCallError
         next
       end

data/lib/samagotchi/session_manager.rb

@@ -11,6 +11,8 @@ require_relative "analytics_file"
 require_relative "atomic_file"
 require_relative "config"
 require_relative "delivery"
+require_relative "steer"
+require_relative "participant_messages"
 
 require_relative "session"
 require_relative "session_inbox"
@@ -1216,6 +1218,9 @@ module Samagotchi
     #   owner (Web::Principal#author: chi web stamps it, never the body);
     #   to the Bridge or the file only when given, so an owner's turn is
     #   sent and saved as before
+    # @param pending_limit [Integer, nil] with +author+: how many of their
+    #   turns may be running or waiting (the Bridge counts them; with no
+    #   worker, their waiting files): :refused 429 too_many_turns past it
     # @param manager [#resume_session, #write_turn_input] this class, or a
     #   stand-in (the web's specs); #session_owner is optional
     # @param bridge [#call, nil] returns the BridgeClient or nil; defaults to
@@ -1229,7 +1234,7 @@ module Samagotchi
     # @raise [OwnedByTUI] a chi REPL owns the session
     # @raise [ArgumentError] no such session
     def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], delivery: nil, no_interrupt: false,
-                          author: nil, state_dir: nil, manager: self, bridge: nil)
+                          author: nil, pending_limit: nil, state_dir: nil, manager: self, bridge: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
       manager.resume_session(session_id, state_dir: state_dir)
@@ -1237,6 +1242,8 @@ module Samagotchi
         # A worker from before queueing (no "delivery" feature) ignores the
         # field or refuses it; either way a file would steer the running turn.
         return queue_unavailable if Delivery.queue?(delivery) && !worker_queues?(session_dir)
+        # A participant's turn only to a worker with the review boundary.
+        return review_unavailable if Steer.participant_author?(author) && !worker_has?(session_dir, Delivery::REVIEW_FEATURE)
 
         begin
           options = { prompt: prompt, client_id: client_id }
@@ -1245,6 +1252,7 @@ module Samagotchi
           options[:delivery] = delivery unless Delivery.next_step?(delivery)
           options[:no_interrupt] = true if no_interrupt
           options[:author] = author if author
+          options[:pending_limit] = pending_limit if author && pending_limit
           reply = client.post_turn(**options)
           ack = reply.json
           return DeliverResult.new(status: :accepted, via: :bridge, ack: ack) if reply.status == 202 && ack.is_a?(Hash)
@@ -1267,6 +1275,20 @@ module Samagotchi
           nil # the worker closed its Bridge on the way out: queue the file
         end
       end
+      # A participant's file only for a worker started after it: a worker
+      # still holding the session with its Bridge gone (exiting) may be an
+      # older one, which would run it without the review boundary.
+      # (A chi REPL holding it is refused as for anyone, below.)
+      if Steer.participant_author?(author) && (holder = delivery_owner(manager, session_id, state_dir)) && !holder.tui?
+        return DeliverResult.new(status: :timeout, via: :file,
+                                 ack: { "error" => "worker_timeout",
+                                        "detail" => "the session's worker is exiting, so the message was not sent; send it again" })
+      end
+      # No worker: the participant's waiting files are all their turns.
+      if author && pending_limit && pending_files(session_dir, author) >= pending_limit
+        return DeliverResult.new(status: :refused, code: 429,
+                                 ack: { "error" => "too_many_turns", "detail" => ParticipantMessages::TOO_MANY_TURNS })
+      end
       enqueued_id = SecureRandom.uuid
       input = { prompt: prompt, client_id: client_id, enqueued_id: enqueued_id, state_dir: state_dir }
       input[:images] = images unless images.empty?
@@ -1294,15 +1316,33 @@ module Samagotchi
     # Whether the session's live worker runs delivery: queue (its sidecar
     # names the feature). No sidecar to read (the client came from a stand-in,
     # or it went between the wait and here): true, the post finds out.
-    private_class_method def self.worker_queues?(session_dir)
+    private_class_method def self.worker_queues?(session_dir) = worker_has?(session_dir, Delivery::QUEUE_FEATURE)
+
+    # Whether the session's live worker names +feature+ in its sidecar; no
+    # sidecar to read: true, as for #worker_queues?.
+    private_class_method def self.worker_has?(session_dir, feature)
       sidecar = WorkerSidecar.read(session_dir)
-      sidecar.nil? || sidecar.features.include?(Delivery::QUEUE_FEATURE)
+      sidecar.nil? || sidecar.features.include?(feature)
+    end
+
+    # The unclaimed input files +author+ wrote.
+    private_class_method def self.pending_files(session_dir, author)
+      SessionInbox.find_new_input_files(session_dir).count do |file|
+        data = JSON.parse(File.read(file))
+        data.is_a?(Hash) && data["author"] == author
+      rescue JSON::ParserError, SystemCallError
+        false
+      end
     end
 
     private_class_method def self.queue_unavailable
       DeliverResult.new(status: :refused, code: 409, ack: Delivery::QUEUE_UNAVAILABLE)
     end
 
+    private_class_method def self.review_unavailable
+      DeliverResult.new(status: :refused, code: 409, ack: Delivery::REVIEW_UNAVAILABLE)
+    end
+
     private_class_method def self.turn_timeout
       DeliverResult.new(status: :timeout, via: :bridge,
                         ack: { "error" => "worker_timeout",

data/lib/samagotchi/session_metrics/side_totals.rb

@@ -12,12 +12,16 @@ module Samagotchi
     # +cost_sum+ is nil until a request reports a cost (a reported 0
     # included), +cost_estimate_sum+ 0 until one is estimated from a price
     # (ModelPrice.estimate, the turns' rule). +by_kind+ is a frozen Hash
-    # kind => {requests:, cost_sum:, cost_estimate_sum:} in first-seen order.
+    # kind => {requests:, cost_sum:, cost_estimate_sum:} in first-seen order;
+    # +by_author+ the same rows by the participant who caused them ("p:<id>":
+    # their turn's ctx.ask_model, the recap after it), the owner's not kept.
     class SideTotals < Data.define(:requests, :prompt_sum, :completion_sum, :cached_sum, :cache_write_sum,
-                                   :reasoning_sum, :cost_sum, :cost_estimate_sum, :by_kind)
+                                   :reasoning_sum, :cost_sum, :cost_estimate_sum, :by_kind, :by_author)
       # The counts summed as they are (the costs and by_kind apart).
       COUNTS = %i[requests prompt_sum completion_sum cached_sum cache_write_sum reasoning_sum].freeze
 
+      def initialize(by_author: {}.freeze, **) = super
+
       def self.zero
         new(**COUNTS.to_h { |key| [key, 0] }, cost_sum: nil, cost_estimate_sum: 0, by_kind: {}.freeze)
       end
@@ -35,7 +39,7 @@ module Samagotchi
           **COUNTS.to_h { |key| [key, count(hash[key.to_s])] },
           cost_sum: cost(hash["cost_sum"]),
           cost_estimate_sum: number(hash["cost_estimate_sum"]),
-          by_kind: saved_kinds(hash["by_kind"])
+          by_kind: saved_kinds(hash["by_kind"]), by_author: saved_kinds(hash["by_author"])
         )
       end
 
@@ -59,13 +63,14 @@ module Samagotchi
         one = { requests: 1, cost_sum: usage.cost&.to_f, cost_estimate_sum: estimate || 0 }
         kind = usage.kind.to_s
         rows = by_kind.merge(kind => sum_row(by_kind[kind], one))
+        authors = usage.author ? by_author.merge(usage.author => sum_row(by_author[usage.author], one)).freeze : by_author
         with(requests: requests + 1, prompt_sum: prompt_sum + usage.prompt_tokens.to_i,
              completion_sum: completion_sum + usage.completion_tokens.to_i,
              cached_sum: cached_sum + usage.cached_tokens.to_i,
              cache_write_sum: cache_write_sum + usage.cache_write_tokens.to_i,
              reasoning_sum: reasoning_sum + usage.reasoning_tokens.to_i,
              cost_sum: add_cost(cost_sum, one[:cost_sum]),
-             cost_estimate_sum: cost_estimate_sum + one[:cost_estimate_sum], by_kind: rows.freeze)
+             cost_estimate_sum: cost_estimate_sum + one[:cost_estimate_sum], by_kind: rows.freeze, by_author: authors)
       end
 
       # These totals with +other+'s added (a loaded block and the requests
@@ -74,18 +79,27 @@ module Samagotchi
       # @return [SideTotals]
       def merge(other)
         rows = other.by_kind.each_with_object(by_kind.dup) { |(kind, row), all| all[kind] = sum_row(all[kind], row) }
+        authors = other.by_author.each_with_object(by_author.dup) { |(who, row), all| all[who] = sum_row(all[who], row) }
         with(**COUNTS.to_h { |key| [key, public_send(key) + other.public_send(key)] },
              cost_sum: add_cost(cost_sum, other.cost_sum),
-             cost_estimate_sum: cost_estimate_sum + other.cost_estimate_sum, by_kind: rows.freeze)
+             cost_estimate_sum: cost_estimate_sum + other.cost_estimate_sum, by_kind: rows.freeze, by_author: authors.freeze)
       end
 
       def empty? = requests.zero?
 
-      # The snapshot's side block (symbol keys; by_kind keyed by kind).
+      # The snapshot's side block (symbol keys; by_kind keyed by kind;
+      # by_author only when a participant caused any).
       # @return [Hash]
       def to_h
         counts = COUNTS.to_h { |key| [key, public_send(key)] }
-        counts.merge(cost_sum: cost_sum, cost_estimate_sum: cost_estimate_sum, by_kind: by_kind.transform_values(&:dup))
+        block = counts.merge(cost_sum: cost_sum, cost_estimate_sum: cost_estimate_sum, by_kind: by_kind.transform_values(&:dup))
+        by_author.empty? ? block : block.merge(by_author: by_author.transform_values(&:dup))
+      end
+
+      # The dollars +author+'s side requests cost (reported and estimated).
+      def spent_by(author)
+        row = by_author[author] or return 0.0
+        row[:cost_sum].to_f + row[:cost_estimate_sum].to_f
       end
 
       def self.count(value) = value.is_a?(Numeric) ? value.to_i : 0