samagotchi 0.104.0 → 0.106.0

data/lib/samagotchi/bridge.rb

@@ -22,6 +22,7 @@ require_relative "engine"
 require_relative "session_commands"
 require_relative "queued_command"
 require_relative "steer"
+require_relative "participants"
 require_relative "image_store"
 require_relative "log"
 require_relative "version"
@@ -322,11 +323,12 @@ module Samagotchi
     # @param after_file [String, nil] the input file it came in (its
     #   basename): it runs once that file is taken (Worker#on_command)
     # @return [String] its command_id
-    def queue_command(line, client_id: nil, card: false, after_file: nil, enqueued_id: nil)
+    def queue_command(line, client_id: nil, card: false, after_file: nil, enqueued_id: nil, author: nil)
       # A card's action (the step-limit question's answer): the UIs leave
       # its line out. +enqueued_id+: a file-delivered command's input, whose
-      # sender's wait its command_ran settles.
-      command = QueuedCommand.mint(line.to_s.strip, client_id: client_id, card: card).with(enqueued_id: enqueued_id)
+      # sender's wait its command_ran settles. +author+: its input's.
+      command = QueuedCommand.mint(line.to_s.strip, client_id: client_id, card: card, author: author)
+                             .with(enqueued_id: enqueued_id)
       @engine.synchronize_events { queue_command_locked(command, after_file: after_file) }
       command.command_id
     end
@@ -542,8 +544,11 @@ module Samagotchi
     # Stop's last_turn carry the turn's enqueued_id (ReplyWait.own_turn).
     # unqueue: POST turn/dequeue (#handle_dequeue_turn) takes a queued
     # message back before it runs.
+    # review_turns: a participant's turn runs as its own, inside the review
+    # boundary (Guardrails::ReviewBoundary); a worker without it has none,
+    # so chi web sends it no participant's turn (Delivery::REVIEW_FEATURE).
     FEATURES = ["restart", "task_stop", "reparent", Delivery::QUEUE_FEATURE, ReplyWait::TURN_IDS_FEATURE,
-                SessionInbox::UNQUEUE_FEATURE].freeze
+                SessionInbox::UNQUEUE_FEATURE, Delivery::REVIEW_FEATURE].freeze
 
     # The routes, by method and what follows /session/:id/: a handler takes
     # the session id and the request body and returns [headers, status, body].
@@ -792,10 +797,11 @@ module Samagotchi
 
     # Queues +line+ (a session command) for the worker and announces its
     # :command_queued, unless +deadline+ has passed. Returns [headers,
-    # status, body]: 202 with its command_id, or 408.
-    def queue_command_request(session_id, line, client_id:, deadline: nil, card: false)
+    # status, body]: 202 with its command_id, or 408. +author+: a POST
+    # /turn's (a /word sent as a message).
+    def queue_command_request(session_id, line, client_id:, deadline: nil, card: false, author: nil)
       # A card's action: the UIs leave its line out (the card is the echo).
-      command = QueuedCommand.mint(line, client_id: client_id, card: card)
+      command = QueuedCommand.mint(line, client_id: client_id, card: card, author: author)
       queued = @engine.synchronize_events do
         raise IntakeClosed if stopped?
         next false if expired?("command_expired", deadline, sid: session_id, client_id: command.client_id)
@@ -914,13 +920,26 @@ module Samagotchi
       end
 
       delivery = Delivery.parse(raw_delivery)
+      # How many of a participant's turns may be running or waiting
+      # (chi web's, from their grant: its queue limit plus the running one).
+      pending_limit = nil
+      if Steer.participant_author?(author)
+        # A participant's message is a turn of its own, whatever the body
+        # asks (D6), and never a command or a shell line: chi web refuses
+        # those first, and this is the worker's own layer.
+        return participant_refused(sid, author, "command") if command_registry.command?(prompt.to_s)
+
+        delivery = Delivery::QUEUE
+        pending_limit = fetched(parsed, "pending_limit")
+        pending_limit = nil unless pending_limit.is_a?(Integer) && pending_limit.positive?
+      end
 
       # A session command sent as a message (chi send -m "/model x", chi -p,
       # a UI whose command list lags) runs as the command, as typed in a
       # TUI; an unknown /word stays a prompt. Not with images: those are
       # for the model.
       if images.empty? && @on_command && command_registry.command?(prompt.to_s)
-        return queue_command_request(sid, prompt.to_s.strip, client_id: client_id, deadline: deadline)
+        return queue_command_request(sid, prompt.to_s.strip, client_id: client_id, deadline: deadline, author: author)
       end
 
       enqueued_id = SecureRandom.uuid
@@ -936,6 +955,7 @@ module Samagotchi
       enqueued = @engine.synchronize_events do
         raise IntakeClosed if stopped?
         next :expired if expired?("turn_expired", deadline, sid: sid, client_id: client_id)
+        next :too_many if pending_limit && pending_turns(author) >= pending_limit
 
         queued_behind_turn = Delivery.queue?(delivery) && !@accumulator.current_turn.nil?
         enqueue_turn(prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
@@ -945,11 +965,13 @@ module Samagotchi
           enqueued_event = { type: :turn_enqueued, enqueued_id: enqueued_id, client_id: client_id, prompt: prompt.to_s }
           enqueued_event[:images] = images unless images.empty?
           enqueued_event[:delivery] = Delivery::QUEUE if queued_behind_turn
+          enqueued_event[:author] = author if author
           @engine.announce(enqueued_event)
           @on_input&.call
         end
       end
       return deadline_passed("turn") if enqueued == :expired
+      return [{}, 429, { error: "too_many_turns", detail: ParticipantMessages::TOO_MANY_TURNS }] if enqueued == :too_many
       return [{}, 500, { error: "enqueue_failed", detail: "could not write turn input" }] unless enqueued
 
       # Queued (outside the event lock): a message sent as +cut+ cuts a
@@ -1003,6 +1025,21 @@ module Samagotchi
       dequeue_reply(taken, id, input)
     end
 
+    # +author+'s turns running or waiting: the running turn when it is
+    # theirs, and their queued ones. Read with the event log held.
+    def pending_turns(author)
+      running = Steer.sender_author(@accumulator.current_turn&.dig(:origin, :author)) == author ? 1 : 0
+      running + @accumulator.queued.count { |row| row[:author] == author }
+    end
+
+    # 403 not_permitted for a participant's +what+ (a command, a shell
+    # line), with its audit line.
+    def participant_refused(sid, author, what)
+      Participants.log(sid, :refused, state_dir: File.dirname(session_dir), participant: author.delete_prefix("p:"), what: what,
+                                      reason: "not_permitted")
+      [{}, 403, { error: "not_permitted", detail: Participants::NOT_PERMITTED }]
+    end
+
     def dequeue_reply(taken, id, input)
       case taken
       when :removed then [{}, 200, { status: "removed", enqueued_id: id, prompt: input.prompt.to_s, session_id: @session_id }]

data/lib/samagotchi/bridge_client.rb

@@ -167,10 +167,13 @@ module Samagotchi
     #   the session's images/
     # @param author [String, nil] who wrote it when it isn't the session's
     #   owner; sent only when given (SessionManager.deliver_turn)
-    def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil, delivery: nil, author: nil)
+    # @param pending_limit [Integer, nil] with a participant's +author+: how
+    #   many of their turns may be running or waiting (429 too_many_turns past it)
+    def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil, delivery: nil, author: nil, pending_limit: nil)
       body = { session_id: @session_id, prompt: prompt, client_id: client_id }
       body[:no_interrupt] = true if no_interrupt
       body[:author] = author if author
+      body[:pending_limit] = pending_limit if author && pending_limit
       body[:images] = images if images && !images.empty?
       body[:delivery] = delivery unless delivery.nil? || Delivery.next_step?(delivery)
       body[:deadline] = deadline

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.104.0
+version: 0.106.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/client_id.rb

@@ -34,12 +34,16 @@ module Samagotchi
     PLUGIN = "plugin"
     # A relayed answer (RelayVerifier): relay:<parent8>.
     RELAY_PREFIX = "relay:"
+    # A participant's review turn: review:<participant id> (chi web stamps
+    # it from the participant's token, never from the request's body).
+    REVIEW_PREFIX = "review:"
 
-    # Input a human typed: a web tab, a chi TUI, chi send, and nil (a
-    # worker's initial prompt; a web client may send none). An allowlist:
-    # delegates, plugins, reminders, context changes and any id chi doesn't
-    # know are not.
-    HUMAN_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
+    # Input a human typed: a web tab, a chi TUI, chi send, a participant
+    # (review:, a person or an agent they run: never automatic input), and
+    # nil (a worker's initial prompt; a web client may send none). An
+    # allowlist: delegates, plugins, reminders, context changes and any id
+    # chi doesn't know are not.
+    HUMAN_PREFIXES = [WEB_PREFIX, TUI_PREFIX, REVIEW_PREFIX].freeze
     HUMAN_IDS = [CLI_SEND].freeze
 
     # A person at a screen that shows a command's reply and can answer it
@@ -47,16 +51,17 @@ module Samagotchi
     INTERACTIVE_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
 
     # A turn's origin by its sender (#origin, LastTurn#origin): the ids chi
-    # runs turns for on its own, by prefix; system:reminder is "reminder",
-    # anything else "client".
+    # runs turns for on its own, by prefix, and a participant's ("review");
+    # system:reminder is "reminder", anything else "client".
     ORIGIN_PREFIXES = { DELEGATE_PREFIX => "delegate", CHILD_PREFIX => "delegate_report",
-                        CONTEXT_PREFIX => "context", TASK_PREFIX => "task" }.freeze
+                        CONTEXT_PREFIX => "context", TASK_PREFIX => "task", REVIEW_PREFIX => "review" }.freeze
 
     module_function
 
     # What sent a turn: "delegate" (a delegating parent), "delegate_report"
     # (a child's report), "context" (a context wake), "task" (a task finish
-    # wake), "reminder", else "client" (a person, chi send, a plugin, nil).
+    # wake), "review" (a participant), "reminder", else "client" (the
+    # owner, chi send, a plugin, nil).
     # @return [String]
     def origin(client_id)
       id = client_id.to_s
@@ -81,5 +86,12 @@ module Samagotchi
       id = client_id.to_s
       HUMAN_IDS.include?(id) || HUMAN_PREFIXES.any? { |prefix| id.start_with?(prefix) }
     end
+
+    # The client id a participant's turn carries (chi web's, from their
+    # grant): review:<participant id>.
+    def review(participant_id) = "#{REVIEW_PREFIX}#{participant_id}"
+
+    # Whether +client_id+ is a participant's (review:).
+    def review?(client_id) = client_id.to_s.start_with?(REVIEW_PREFIX)
   end
 end

data/lib/samagotchi/config.rb

@@ -306,11 +306,16 @@ module Samagotchi
       Entry.new(key: "web.view",                 yaml_path: %w[web view],                 type: :enum,    default: "stage",        expose: %i[env config cli], enum_values: %w[stage turn], lifecycle: :web_start),
       # The stage view's working set (files, memories and URLs the turn brought into context): a rail in the stage, a
       # footprint under each finished turn and a "set N" chip in place of the mem chip; ?working_set=1|0 overrides it per page load.
-      Entry.new(key: "web.working_set",          yaml_path: %w[web working_set],          type: :bool,    default: false,           expose: %i[env config cli], lifecycle: :web_start),
+      Entry.new(key: "web.working_set",          yaml_path: %w[web working_set],          type: :bool,    default: true,            expose: %i[env config cli], lifecycle: :web_start),
       # Quick replies next to Annotate in the page's selection bubble, "|"-separated (a YAML list works too); "" leaves only Annotate.
       Entry.new(key: "web.annotate_presets",     yaml_path: %w[web annotate_presets],     type: :string, default: "Agreed|Could you please elaborate?", expose: %i[env config cli], lifecycle: :web_start),
       # What a file ref (a tool row's file, a diff line) opens on this machine: a preset (vscode, vscode-insiders, cursor, zed, none) or a URL template with {path} and an optional {line} (Web::Editor).
       Entry.new(key: "web.editor",               yaml_path: %w[web editor],               type: :string, default: "vscode",        expose: %i[env config cli], lifecycle: :web_start),
+      # Participants (chi share): a new grant's lifetime (Nh or Nd, 1h to 30d), and what a grant without its own
+      # takes: its spending cap in dollars ($0 to $1000) and how many of its turns may wait (0 to 20). Read when used.
+      Entry.new(key: "web.participants.expires", yaml_path: %w[web participants expires], type: :string, default: "7d", expose: %i[env config], lifecycle: :next_matching_turn_display_poll_write),
+      Entry.new(key: "web.participants.cap",     yaml_path: %w[web participants cap],     type: :float,  default: 2.0,  expose: %i[env config], lifecycle: :next_matching_turn_display_poll_write),
+      Entry.new(key: "web.participants.queue",   yaml_path: %w[web participants queue],   type: :integer, default: 3,   expose: %i[env config], lifecycle: :next_matching_turn_display_poll_write),
 
       Entry.new(key: "no_interrupt",             yaml_path: %w[no_interrupt],             type: :bool,   default: false,            expose: %i[env config cli], lifecycle: :next_cli_run),
       Entry.new(key: "no_default_input",         yaml_path: %w[no_default_input],         type: :bool,   default: false,            expose: %i[env config cli], lifecycle: :next_cli_run),
@@ -609,7 +614,7 @@ module Samagotchi
           elsif MAP_ENTRY_KEYS.key?(key)
             map_entry_problems(key, value)
           elsif value.is_a?(Hash) && (known_sections.include?(key) || ENTRIES.any? { |e| e.yaml_path.size > 1 && e.section == key })
-            value.keys.filter_map { |leaf| key_problem("#{key}.#{leaf}") }
+            value.flat_map { |leaf, inner| leaf_problems("#{key}.#{leaf}", inner) }
           elsif known_sections.include?(key)
             # An all-commented section is nil; recap: false turns recaps off.
             value.nil? || (key == "recap" && value == false) ? [] : ["config: '#{key}' must be a mapping of settings; ignored"]
@@ -619,6 +624,16 @@ module Samagotchi
         end + model_ref_problems(data)
       end
 
+      # A section's leaf: a key the registry knows, or a mapping of a
+      # third level (web.participants.cap) whose keys it knows.
+      def leaf_problems(path, value)
+        if value.is_a?(Hash) && ENTRIES.any? { |e| e.key.start_with?("#{path}.") }
+          value.keys.filter_map { |leaf| key_problem("#{path}.#{leaf}") }
+        else
+          [key_problem(path)].compact
+        end
+      end
+
       # What a model ref in config.yml won't do as written: an alias whose
       # target is another alias (aliases apply once, ModelRef), a ref that
       # starts with "<host>/" (only ':' names a host).

data/lib/samagotchi/continue_offer.rb

@@ -3,6 +3,7 @@
 require "time"
 require_relative "last_turn"
 require_relative "log"
+require_relative "steer"
 
 module Samagotchi
   # A session worker's continue offer: what it announces when a turn runs out
@@ -34,12 +35,15 @@ module Samagotchi
     # @param max_iterations [#call] (no_interrupt) → Integer
     # @param queue_command [#call] (line, client_id:) queues a session
     #   command as a card's (Bridge#queue_command, card: true)
-    def initialize(engine:, turn_flow:, run_turn:, max_iterations:, queue_command: nil)
+    # +participant_refused+ (author → Boolean): whether a participant's
+    # turn may no longer run (revoked, expired, at the cap: Worker's check).
+    def initialize(engine:, turn_flow:, run_turn:, max_iterations:, queue_command: nil, participant_refused: ->(_) { false })
       @engine = engine
       @turn_flow = turn_flow
       @run_turn = run_turn
       @max_iterations = max_iterations
       @queue_command = queue_command
+      @participant_refused = participant_refused
       # A question was posted since the last close (it may have been
       # answered or superseded meanwhile).
       @asked = false
@@ -124,12 +128,18 @@ module Samagotchi
     # never began leaves it to no other.
     # The continue turn is the offer turn's: its origin carries that turn's
     # enqueued_id, so its last_turn, its reply file and its checkpoint mark
-    # do too, and a wait on that turn (chi answer) gets its reply.
+    # do too, and a wait on that turn (chi answer) gets its reply; and its
+    # author, so a participant's turn continues as theirs, inside the
+    # review boundary and on their spend (never as the owner's). One whose
+    # participant may no longer run a turn isn't continued.
     def run_continue_turn(command)
       offer = @turn_flow.offer
       resume_from = @turn_flow.resume_from
       enqueued_id = offer_turn_id
+      author = Steer.sender_author(@engine.session&.last_turn&.author)
       close("answered")
+      return if author && @participant_refused.call(author)
+
       steer = @continue_steer
       @continue_steer = nil
       begin
@@ -140,7 +150,7 @@ module Samagotchi
           Log.warn(:worker, "turn_not_begun", continue: true, error: e.class.name, msg: e.message)
           return announce_offer(offer)
         end
-        origin = { client_id: command.client_id, enqueued_id: enqueued_id }.compact
+        origin = { client_id: command.client_id, enqueued_id: enqueued_id, author: author }.compact
         @run_turn.call(nil, continue: true, origin: origin, resumed: true, resume_from: resume_from,
                             max_iterations: @max_iterations.call(offer[:no_interrupt])) do |result, error|
           if error

data/lib/samagotchi/delivery.rb

@@ -48,6 +48,16 @@ module Samagotchi
                   "restart it (chi sessions restart ID, or the web's update badge) and send again"
     }.freeze
 
+    # A worker that runs participants' turns inside the review boundary
+    # (Bridge::FEATURES): one without it would run theirs with the owner's
+    # tools, so none is sent to it.
+    REVIEW_FEATURE = "review_turns"
+    REVIEW_UNAVAILABLE = {
+      "error" => "review_unavailable",
+      "detail" => "this session's worker predates participants' turns, so it has no review boundary; " \
+                  "the owner must restart it (chi sessions restart ID, or the web's update badge)"
+    }.freeze
+
     # Whether it is the one every sender defaulting to a step boundary uses.
     def self.next_step?(value) = parse(value) == NEXT_STEP
 

data/lib/samagotchi/engine.rb

@@ -85,6 +85,8 @@ require_relative "guardrail_wiring"
 require_relative "plugin_tasks"
 require_relative "prompt_warmup"
 require_relative "working_set"
+require_relative "participants_watch"
+require_relative "session_participants"
 
 module Samagotchi
   # Engine owns the core agent logic: system prompt construction, tool
@@ -218,6 +220,13 @@ module Samagotchi
       Log.debug(:model, "backend", provider: backend.provider) if Log.level?(:debug)
       @resume_session = session_id ? Session.load(session_id) : nil
       @prompt_builder = build_system_prompt(memories, appended_prompt_files)
+      # The session's participants (participants.json), read at each turn's
+      # start: their names for the messages they wrote.
+      @participants = SessionParticipants.new(state_dir: -> { session_state_dir })
+      # Whether the system prompt carries the participants line.
+      @participants_line = false
+      # Who is in the review now, and who came or went (#announce_participants).
+      @participants_watch = ParticipantsWatch.new(session_id: -> { @session&.id }, state_dir: -> { session_state_dir })
       @session = nil
       @session_observer = SessionObserver.new
       @metrics = SessionMetrics.new
@@ -414,7 +423,8 @@ module Samagotchi
       SystemPrompt.new(profile: -> { profile }, tools: -> { @tools }, session: -> { @session },
                        thinking: -> { turn_thinking }, model: -> { model_identity },
                        model_notes: -> { model_notes }, memories: memories,
-                       muted_memory_names: @muted_memory_names, appended_files: appended_prompt_files)
+                       muted_memory_names: @muted_memory_names, appended_files: appended_prompt_files,
+                       participants: -> { @participants_line })
     end
     private :build_system_prompt
 
@@ -588,9 +598,12 @@ module Samagotchi
     # recreate a deleted session's folder; the folder itself may not exist
     # yet before a first turn). Safe from any thread: the recap's, a
     # plugin's, the turn's.
+    # A side request counts against the participant who caused it
+    # (#side_author), its usage's own author when it names one.
     # @param usage [SideUsage]
     # @return [void]
     def note_side_usage(usage)
+      usage = usage.with(author: side_author(usage.kind)) if usage.author.nil?
       synchronize_events do
         block = @metrics.add_side(usage)
         @session_observer.notify(type: :side_usage, kind: usage.kind, side: block)
@@ -602,6 +615,24 @@ module Samagotchi
       @metrics.persist(state_dir: session_state_dir)
     end
 
+    # Who caused a side request of +kind+ now: the running turn's author (a
+    # plugin's ctx.ask_model in it), the last turn's for the idle recap
+    # (it recaps that turn); nil, the owner's, for anything else (an owner
+    # command's ask_model between turns).
+    # @return [String, nil]
+    def side_author(kind)
+      return nil unless turn_running? || kind.to_s == RECAP_SIDE_KIND
+
+      Steer.sender_author(@guardrail_wiring.turn_author)
+    end
+
+    RECAP_SIDE_KIND = "recap"
+
+    # The running turn's author when a participant wrote it, else nil
+    # (ctx.turn_author, the hooks' author).
+    # @return [String, nil]
+    def turn_author = turn_running? ? Steer.sender_author(@guardrail_wiring.turn_author) : nil
+
     # @return [SessionMetrics] the per-session analytics collector
     attr_reader :metrics
 
@@ -790,7 +821,7 @@ module Samagotchi
     # UIs need in the event log, emitted outside any turn's stream.
     ANNOUNCEABLE_EVENTS = %i[turn_enqueued turn_dequeued input_merged prompt_restored continue_offered continue_resolved
                              command_queued command_ran context_added card hook_notice guardrail_warning
-                             plugin_init_started plugin_init_finished working_set_updated].freeze
+                             plugin_init_started plugin_init_finished working_set_updated participants_changed].freeze
 
     # Put a transport-level event into the ordered event log. Unlike turn
     # events it reaches only persistent observers (no turn sink, no memory
@@ -1179,6 +1210,11 @@ module Samagotchi
                                 price_host: model.host_name)
       kit_prompt = kit_prompt_stats
       snapshot = snapshot.merge(kit_prompt: kit_prompt) if kit_prompt
+      # Each participant's spend under their name (participants.json's).
+      if (spend = snapshot[:spend_by_author])
+        named = spend.to_h { |author, row| [author, row.merge(name: @participants.name_for(author, session: @session))] }
+        snapshot = snapshot.merge(spend_by_author: named)
+      end
       # The session's own settings (chi --set), as --set names them.
       settings = @session&.settings&.flat || {}
       snapshot = snapshot.merge(settings: settings) unless settings.empty?
@@ -1295,6 +1331,8 @@ module Samagotchi
     #     that served model under served: (#served_expected_by)
     #   :recap_enabled [Boolean]   whether an idle recap is configured, with
     #     :recap_min_user_turns and :recap_inactivity_seconds (nil when not)
+    #   :participants  [Array<Hash>] who is in the review now ({id:, name:,
+    #     kind:}; ParticipantsWatch#active), [] for nobody
     def session_state_snapshot
       served_pair = served_model(probe: false)
       metrics = @metrics.snapshot
@@ -1323,7 +1361,8 @@ module Samagotchi
         **setting_chips(SessionSetting::ALL, model),
         recap_enabled: !@recap.nil?,
         recap_min_user_turns: @recap&.min_user_turns,
-        recap_inactivity_seconds: @recap&.inactivity&.to_i
+        recap_inactivity_seconds: @recap&.inactivity&.to_i,
+        participants: @participants_watch.active
       }
     end
 
@@ -1462,9 +1501,46 @@ module Samagotchi
       session.last_turn = LastTurn.new(outcome: outcome, ended_at: Time.now.iso8601(3), seconds: seconds.round(1),
                                        origin: source, exhausted: limit ? true : nil, limit: limit,
                                        enqueued_id: enqueued_id.to_s.empty? ? nil : enqueued_id.to_s,
+                                       author: Steer.sender_author(origin.is_a?(Hash) ? origin[:author] : nil),
                                        **stop_facts(event))
     end
 
+    # A participant joined (invited) or left (revoked, expired) since the
+    # last look: :participants_changed to the observers (ParticipantsWatch;
+    # the worker looks on its idle tick). The first look announces nobody.
+    # @return [ParticipantsWatch::Change, nil]
+    def announce_participants
+      change = @participants_watch.changes or return nil
+
+      announce(change.to_event)
+      change
+    end
+
+    # Reads the session's participants at a turn's start; the first to join
+    # and the last to leave rebuild the system prompt (its participants
+    # line), once each: a turn in between sends the same prefix.
+    def refresh_participants!(session)
+      active = @participants.refresh!(session).active?
+      return if active == @participants_line
+
+      @participants_line = active
+      @prompt_builder.reset!
+    end
+    private :refresh_participants!
+
+    # The author fields a message +author+ wrote carries (Steer.author_fields:
+    # author:, and author_name: from participants.json), {} for the owner.
+    # The worker's drain names a participant's merged lines with it, and
+    # its running save a participant's prompt.
+    # @param origin [Hash, String, nil] a turn's origin, or an author
+    # @param session [Session, nil] the session it is for (the turn's)
+    def author_fields(origin, session: @session)
+      author = origin.is_a?(Hash) ? origin[:author] : origin
+      return {} unless Steer.participant_author?(author)
+
+      Steer.author_fields(author, @participants.name_for(author, session: session))
+    end
+
     # Why a turn stopped, from its end event (LastTurn::STOP_FACTS), for a
     # parent agent's wait (ReplyWait): a provider error's kind and whether
     # a retry may help, a cancel's reason and the hook that stopped it.
@@ -1607,7 +1683,8 @@ module Samagotchi
         event_routes: @event_routes,
         question_desk: -> { @question_desk },
         cancel_controller: -> { active_cancel_controller },
-        steer: ->(text, source) { steer(text, source: source) }
+        steer: ->(text, source) { steer(text, source: source) },
+        turn_author: -> { turn_author }
       )
     end
     private :build_hook_routes
@@ -2072,6 +2149,9 @@ module Samagotchi
       turn_started[:resumed] = true if turn.resumed?
       turn_started[:images] = image_refs unless image_refs.empty?
       turn_started[:cut_after] = steer_cut_after
+      # A participant's turn names them (author, author_name) for the UIs'
+      # badge; the owner's turn_started stays as it was.
+      turn_started.merge!(author_fields(turn.origin, session: session))
       emit_event(turn.on_event, turn.tag(turn_started))
       raise image_error if image_error
 
@@ -2103,6 +2183,7 @@ module Samagotchi
       # prompt built next declares, unchanged until the next turn's start.
       apply_staged_tools!
       apply_toolkit!(session, turn.on_event)
+      refresh_participants!(session)
       # A Stop during the wait above: the turn ends here,
       # before the hooks run or a reminder is used up.
       return false if turn.controller.cancelled?
@@ -2222,7 +2303,9 @@ module Samagotchi
       # Inject due reminders as a tail system message (after history, before
       # the new user prompt) to preserve prefix KV cache. Mutating the head
       # system prompt invalidates cache for the entire prefix.
-      due_reminders = @reminder_queue.inject!(turn.messages)
+      # Not into a participant's turn: the owner's reminders are the owner's,
+      # and would be used up there under the review boundary.
+      due_reminders = Steer.participant_author?(turn.origin&.dig(:author)) ? [] : @reminder_queue.inject!(turn.messages)
       if due_reminders.any?
         emit_event(turn.on_event, {
           type: :reminder_injected,
@@ -2231,7 +2314,7 @@ module Samagotchi
       end
 
       unless turn.continue
-        user_message = { role: "user", content: turn.prompt, turn_id: turn.id }
+        user_message = { role: "user", content: turn.prompt, turn_id: turn.id, **author_fields(turn.origin) }
         user_message[:images] = image_refs unless image_refs.empty?
         turn.messages << user_message
         session.last_prompt = turn.prompt
@@ -2583,12 +2666,18 @@ module Samagotchi
     end
 
     # Restore the current session's conversation to a #messages_checkpoint.
+    # Between turns the working set is announced when that changed it (a
+    # !rollback or a canceled continue dropping the turn's tool calls, the
+    # set emptied too), so the page doesn't keep the dropped items until
+    # the next request.
     # @param checkpoint [Array<Hash>]
     # @return [Array<Hash>] the session's messages
     def rollback_to(checkpoint)
       raise ArgumentError, "no current session" unless @session
 
-      replace_session_messages(@session, clone_messages(checkpoint))
+      messages = replace_session_messages(@session, clone_messages(checkpoint))
+      announce_working_set unless turn_running?
+      messages
     end
 
     # Clone a messages array (shallow dup of each element).
@@ -2792,7 +2881,8 @@ module Samagotchi
         prompt_files: -> { @prompt_builder&.prompt_files || [] },
         frontend: -> { interface },
         cost: -> { @metrics.cost },
-        usage: -> { @metrics.usage }
+        usage: -> { @metrics.usage },
+        turn_author: -> { turn_author }
       )
     end
 

data/lib/samagotchi/guardrail_wiring.rb

@@ -113,11 +113,21 @@ module Samagotchi
 
     # The gate's core checks, in order. A delegate child's boundary comes
     # before the rules, so its ask keeps the child-boundary rule id (and
-    # its once/session scopes) when a strict rule asks too.
+    # its once/session scopes) when a strict rule asks too. The review
+    # boundary comes before both: a participant's turn is denied what it
+    # may not do, never asked about it (deny is sticky, so no later vote
+    # can turn it into a question).
     def checks
       rules = self.rules
-      [@failures, rules.hook_asks, protected_paths, (@scratch_writes ||= Guardrails::ScratchWrites.new if @scratch),
-       child_boundary, rules].compact
+      [@failures, review_boundary, rules.hook_asks, protected_paths,
+       (@scratch_writes ||= Guardrails::ScratchWrites.new if @scratch), child_boundary, rules].compact
+    end
+
+    # A participant's turn's boundary (Guardrails::ReviewBoundary): in
+    # every session, a no-op unless the running turn's author is a
+    # participant's.
+    def review_boundary
+      @review_boundary ||= Guardrails::ReviewBoundary.new(author: -> { turn_author }, root: -> { boundary_root })
     end
 
     # The delegate child's boundary (Guardrails::ChildBoundary); nil for