samagotchi 0.106.0 → 0.108.0

data/lib/samagotchi/session_access/dispatch.rb

@@ -78,7 +78,10 @@ module Samagotchi
       end
 
       # The session command against the remote: refused (exit 2), or run
-      # with a Remote. A failure to reach it is the command's line, exit 1.
+      # with a Remote. A failure to reach it is the command's line, exit 1;
+      # a refusal the command doesn't word itself is its line too: exit 2
+      # when chi web refused a value (BadRequest, a usage error here), 1
+      # for any other.
       # @param subcommands [Hash] bin/chi's SUBCOMMANDS
       # @return [Integer] the exit status
       def run(subcommands, stderr: $stderr, transport: nil)
@@ -100,7 +103,10 @@ module Samagotchi
       rescue Remotes::Invalid => e
         stderr.puts("Error: #{e.message}")
         CLI::Exit::USAGE
-      rescue RemoteFailed => e
+      rescue BadRequest => e
+        stderr.puts("chi #{@argv.first}: #{e.message}")
+        CLI::Exit::USAGE
+      rescue RemoteFailed, Refused => e
         stderr.puts("chi #{@argv.first}: #{e.message}")
         CLI::Exit::FAILED
       end

data/lib/samagotchi/session_access/http_transport.rb

@@ -74,6 +74,13 @@ module Samagotchi
         failed("no answer within #{@open_timeout} s")
       rescue Net::ReadTimeout
         failed("it took the request but sent no answer within #{read_timeout} s")
+      rescue Net::WriteTimeout
+        failed("it took no request within #{read_timeout} s")
+      rescue Timeout::Error
+        failed("no answer in time")
+      rescue Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError
+        # Something else listens there (an SSH banner, another server).
+        failed("it didn't answer HTTP (is it chi web's port?)")
       rescue SocketError => e
         failed(e.message.include?("getaddrinfo") ? "can't find host #{@uri.host}" : e.message)
       rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH
@@ -87,7 +94,9 @@ module Samagotchi
       private
 
       def http(read_timeout)
-        Net::HTTP.new(@uri.host, @uri.port).tap do |http|
+        # hostname: an IPv6 address bare ([::1] is the URL's); Net::HTTP
+        # brackets it in Host.
+        Net::HTTP.new(@uri.hostname, @uri.port).tap do |http|
           http.use_ssl = @uri.scheme == "https"
           http.open_timeout = @open_timeout
           http.read_timeout = read_timeout

data/lib/samagotchi/session_access/local.rb

@@ -12,6 +12,7 @@ require_relative "../context_sources"
 require_relative "../send_command/busy"
 require_relative "../chi_invocation"
 require_relative "../worker_sidecar"
+require_relative "../review_start"
 require_relative "../launch_mode"
 require_relative "../participants"
 require_relative "../config"
@@ -114,8 +115,11 @@ module Samagotchi
       # @return [Session] the session created (its id, model_warning,
       #   continues, moved_children)
       # @raise [SessionContinue::Refused, SessionManager::ArchiveRefused,
-      #   SessionManager::OwnedByTUI] refused; StandardError: could not start
+      #   SessionManager::OwnedByTUI, ReviewStart::Refused] refused;
+      #   StandardError: could not start
       def create(spec)
+        return create_review(spec) if spec.review
+
         start = spec.preview ? { prompt: spec.prompt, preview: spec.preview } : { prompt: spec.prompt }
         if spec.continues
           return SessionManager.continue_session(spec.continues, **start, model: spec.model_name, **dir)
@@ -125,6 +129,18 @@ module Samagotchi
                                               setup: spec.setup, **dir)
       end
 
+      # A review session (ReviewStart): a fork of review.from, or a fresh
+      # one in the spec's folder.
+      def create_review(spec)
+        review = spec.review
+        if review.from
+          return ReviewStart.fork(from: review.from, subjects: review.subjects, model: spec.model_name, state_dir: state_dir!)
+        end
+
+        ReviewStart.start(subjects: review.subjects, dir: spec.working_directory || Dir.pwd, model: spec.model_name,
+                          setup: spec.setup || SessionSetup.new, state_dir: state_dir!)
+      end
+
       # Whether a just-created session's worker came up (its Bridge
       # answers) within +timeout+ seconds.
       def await_worker(id, timeout:)
@@ -353,7 +369,8 @@ module Samagotchi
         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?)
+                       link: "http://#{ip || "127.0.0.1"}:#{port}/?token=#{issued.token}#s=#{id}", lan: !ip.nil?,
+                       warning: ReviewStart.share_warning(Session.load(id, **dir)))
       rescue Web::Grants::Invalid => e
         raise BadRequest.new(e.message, code: "invalid_participant")
       end

data/lib/samagotchi/session_access/remote.rb

@@ -259,7 +259,7 @@ module Samagotchi
 
         json = reply.json
         Invitation.new(participant: ParticipantView.from_h(json.fetch("participant")), token: json.fetch("token"),
-                       link: json.fetch("link"), lan: json["lan"] == true)
+                       link: json.fetch("link"), lan: json["lan"] == true, warning: json["warning"])
       end
 
       # Revokes one participant (+participant+), a session's, or with no
@@ -458,6 +458,7 @@ module Samagotchi
       # @param fetched [ContextSources::Fetched]
       # @return [ContextPush]
       def context_push(target, name, fetched)
+        ContextSources.check_name!(name)
         reply = request(:post, "#{session_path(target.session_id)}/context/#{name}/push",
                         body: { text: fetched.text, summary: fetched.summary, wake: fetched.wake, hint: fetched.hint })
         case reply.status
@@ -647,6 +648,8 @@ module Samagotchi
       end
 
       def create_body(spec)
+        return review_body(spec) if spec.review
+
         body = { model: spec.model_name, client_id: spec.client_id, history: false }
         if spec.preview || spec.idle
           body.merge!(idle: true, preview: spec.preview)
@@ -663,6 +666,17 @@ module Samagotchi
         body.compact
       end
 
+      # A review session's create (chi review): its subjects as typed,
+      # checked by the server against its own files; a fork names its
+      # source and takes its folder.
+      def review_body(spec)
+        review = { subjects: spec.review.subjects, from: spec.review.from }.compact
+        body = { review: review, model: spec.model_name }
+        body[:dir] = spec.working_directory unless spec.review.from
+        body.merge!(setup_body(spec.setup)) if spec.setup && !spec.review.from
+        body.compact
+      end
+
       def setup_body(words)
         llm = words.llm_context&.to_h { |field, word| [LLM_CONTEXT_KEYS.fetch(field), word] }
         { llm_context: llm, thinking: words.thinking, toolkit: words.toolkit,

data/lib/samagotchi/session_access/web_bridge_client.rb

@@ -203,7 +203,7 @@ module Samagotchi
         return refused("tls_unsupported") if uri.scheme == "https"
 
         token = @remote.entry.token
-        opened = BridgeClient::StreamRequest.open(host: uri.host, port: uri.port,
+        opened = BridgeClient::StreamRequest.open(host: uri.hostname, port: uri.port,
                                                   path: "/api/sessions/#{@session_id}/stream#{query}",
                                                   last_event_id: last_event_id, timeout: timeout,
                                                   headers: token ? { "Authorization" => "Bearer #{token}" } : {})

data/lib/samagotchi/session_access.rb

@@ -35,27 +35,27 @@ module Samagotchi
     class AuthRefused < RemoteFailed; end
 
     # The errors a participant's token meets (docs/internals/participants.md),
-    # one message each, built from the remote's label ("remote studio
-    # (http://…)"). chi web's code for each is its CODE.
+    # each the server's own words (ParticipantMessages) led by the remote's
+    # label ("remote studio (http://…)"). chi web's code for each is its CODE.
 
     # 401 token_revoked: the owner revoked the grant, or archived or
     # deleted its session.
     class TokenRevoked < AuthRefused
       CODE = "token_revoked"
-      def initialize(label) = super("#{label}: this review link was revoked by the session's owner")
+      def initialize(label) = super("#{label}: #{ParticipantMessages::TOKEN_REVOKED}")
     end
 
     # 401 token_expired: the grant's time ran out.
     class TokenExpired < AuthRefused
       CODE = "token_expired"
-      def initialize(label) = super("#{label}: this review link expired: ask the session's owner for a new one")
+      def initialize(label) = super("#{label}: #{ParticipantMessages::TOKEN_EXPIRED}")
     end
 
     # 403 not_permitted: a participant's token on a route only the session's
     # owner may use.
     class NotPermitted < RemoteFailed
       CODE = "not_permitted"
-      def initialize(label) = super("#{label}: this token is a participant's: only the session's owner can do that")
+      def initialize(label) = super("#{label}: #{ParticipantMessages::NOT_PERMITTED}")
     end
 
     # 429 too_many_turns (P3b): the participant's turns already wait in the
@@ -102,8 +102,11 @@ module Samagotchi
     # What chi share made: the participant, their token and the link that
     # carries it (both shown this once: chi keeps only a digest), and
     # whether that chi web listens on the LAN (+lan+ false: the link works
-    # on that machine only).
-    Invitation = Data.define(:participant, :token, :link, :lan) do
+    # on that machine only), and the warning for sharing a working session
+    # (ReviewStart.share_warning; nil for a review session).
+    Invitation = Data.define(:participant, :token, :link, :lan, :warning) do
+      def initialize(participant:, token:, link:, lan:, warning: nil) = super
+
       def inspect = "#<Invitation #{participant.id}>"
       alias_method :to_s, :inspect
     end
@@ -120,11 +123,21 @@ module Samagotchi
     # bundles). +client_id+ (chi send's, or chi answer's for a parent's
     # /continue yes) and +images+ (images follow) are for a Remote's server,
     # which checks the first line and the model as chi send checks them
-    # here (Local checks before it creates).
+    # here (Local checks before it creates). +review+ (a Review) makes it a
+    # review session (chi review): idle, no prompt, and with +review.from+
+    # a review fork of that session (its folder and setup: the rest is nil).
     NewSession = Data.define(:prompt, :preview, :continues, :working_directory, :model_name, :setup, :client_id,
-                             :images, :idle) do
+                             :images, :idle, :review) do
       def initialize(prompt:, preview: nil, continues: nil, working_directory: nil, model_name: nil, setup: nil,
-                     client_id: nil, images: false, idle: false) = super
+                     client_id: nil, images: false, idle: false, review: nil) = super
+    end
+
+    # A review session to create (NewSession#review): +subjects+ as typed
+    # (relative to the session's folder; the side that has the files checks
+    # them, ReviewStart.check_subjects), +from+ the session a review fork
+    # starts from (an id, a prefix or last:<id>), or nil.
+    Review = Data.define(:subjects, :from) do
+      def initialize(subjects: [], from: nil) = super(subjects: Array(subjects).map(&:to_s), from: from)
     end
 
     # chi send --new's setup flags as typed, for a Remote: +llm_context+

data/lib/samagotchi/session_chain.rb

@@ -70,12 +70,20 @@ module Samagotchi
     # @return [String]
     def note_text(previous, recap:)
       head = "This session continues #{previous.id[0, 8]} (#{clock(previous.created_at) || previous.created_at}), the previous link of its chain."
+      "#{head}#{recap_text(recap)}"
+    end
+
+    # +recap+ as a note's tail: " Its recap, as of <time>:\n<text>" (cut
+    # to RECAP_CHARS), or " It left no recap."
+    # @param recap [Hash, nil] RecapStore.read's
+    # @return [String]
+    def recap_text(recap)
       text = recap && recap[:text].to_s.strip
-      return "#{head} It left no recap." if text.nil? || text.empty?
+      return " It left no recap." if text.nil? || text.empty?
 
       text = "#{text[0, RECAP_CHARS - 1]}…" if text.length > RECAP_CHARS
       as_of = clock(recap[:created_at])
-      "#{head} Its recap#{", as of #{as_of}" if as_of}:\n#{text}"
+      " Its recap#{", as of #{as_of}" if as_of}:\n#{text}"
     end
 
     # What web `continue →` prefills in +previous+'s next link: +previous+'s

data/lib/samagotchi/session_continue.rb

@@ -204,7 +204,7 @@ module Samagotchi
       end
       link = SessionManager.spawn_session(
         prompt: start, preview: preview, title: previous.title, working_directory: previous.working_directory,
-        model_name: choice.model, setup: SessionSetup.of(previous),
+        model_name: choice.model, setup: SessionSetup.of(previous), review: previous.review,
         continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
         note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn
       )
@@ -300,8 +300,9 @@ module Samagotchi
     # IdleRecap#request_now) and wait, up to +wait+ seconds, for recap.json
     # to change. A worker that is gone wrote its recap when it left; one
     # that has nothing new to say, too short a conversation, or recaps off
-    # answers at once. Best effort: the continue goes on without.
-    private_class_method def self.recap_before_archive(id, state_dir, wait:)
+    # answers at once. Best effort: the continue goes on without. A review
+    # fork (ReviewStart) asks the same, with nothing archived after.
+    def self.recap_before_archive(id, state_dir, wait:)
       return unless SessionManager.worker_live?(id, state_dir: state_dir)
 
       dir = Session.session_dir(id, state_dir: state_dir)

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_manager.rb

@@ -157,6 +157,8 @@ module Samagotchi
     # @param note [String, nil] a context note the session starts with,
     #   from +note_source+: queued before its worker spawns, so its first
     #   turn sees it
+    # @param review [SessionReview, nil] a review session's (ReviewStart; a
+    #   continue keeps its previous link's)
     # @param before_spawn [#call, nil] (session) runs once the session and
     #   its note are saved, before its worker spawns
     # @return [Session] with #seed_images_dropped: refs whose file was gone,
@@ -164,7 +166,7 @@ module Samagotchi
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
                            preview: nil, title: nil, delegate: false, setup: SessionSetup.new, continues: nil, note: nil,
-                           note_source: "chi", before_spawn: nil)
+                           note_source: "chi", before_spawn: nil, review: nil)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
       # alias is retargeted), with the name as typed beside it. A wrong host
@@ -186,7 +188,8 @@ module Samagotchi
         messages: messages,
         delegate: delegate,
         setup: setup,
-        continues: continues
+        continues: continues,
+        review: review
       )
       session.toolkit = Toolkit.configured(delegate: delegate) if session.toolkit.nil?
       session.model_warning = model_warning
@@ -1284,18 +1287,23 @@ module Samagotchi
                                  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?
       input[:delivery] = delivery unless Delivery.next_step?(delivery)
       input[:no_interrupt] = true if no_interrupt
       input[:author] = author if author
-      path = manager.write_turn_input(session_id, **input)
+      path = participant_queue_lock(session_dir, author && pending_limit) do
+        # No worker: the participant's waiting files are all their turns,
+        # counted and written under one lock (the Bridge counts under its).
+        next :too_many if author && pending_limit && pending_files(session_dir, author) >= pending_limit
+
+        manager.write_turn_input(session_id, **input)
+      end
+      if path == :too_many
+        return DeliverResult.new(status: :refused, code: 429,
+                                 ack: { "error" => "too_many_turns", "detail" => ParticipantMessages::TOO_MANY_TURNS })
+      end
       return DeliverResult.new(status: :failed) unless path
 
       owner = delivery_owner(manager, session_id, state_dir)
@@ -1326,6 +1334,20 @@ module Samagotchi
     end
 
     # The unclaimed input files +author+ wrote.
+    PARTICIPANT_QUEUE_LOCK = "participants.lock"
+
+    # The block under the session's participant queue lock (a file lock:
+    # chi web's threads, and another chi web), when +locked+; else as is.
+    private_class_method def self.participant_queue_lock(session_dir, locked)
+      return yield unless locked
+
+      FileUtils.mkdir_p(session_dir)
+      File.open(File.join(session_dir, PARTICIPANT_QUEUE_LOCK), File::RDWR | File::CREAT, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        yield
+      end
+    end
+
     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/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/session_review.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A review session's own field (chi review, the web's Start review): the
+  # files under review, project-relative (the session's work tree top),
+  # and, for a review fork (chi review --from), the session it started from.
+  # A session without one isn't a review session; its file has no "review"
+  # key at all (Session::OPTIONAL_FIELDS), so other session files stay as
+  # they were. Kept by continues; never by forks or delegate children.
+  # See docs/sessions.md (Review sessions).
+  SessionReview = Data.define(:subjects, :from) do
+    def initialize(subjects: [], from: nil)
+      super(subjects: Array(subjects).map(&:to_s).reject(&:empty?).uniq.freeze, from: from&.to_s)
+    end
+
+    # A SessionReview from the session file's form ({"subjects" => […],
+    # "from" => id}), a SessionReview, or nil (nil for nil or a non-hash).
+    def self.of(value)
+      case value
+      when SessionReview then value
+      when Hash then new(subjects: value["subjects"] || value[:subjects], from: value["from"] || value[:from])
+      end
+    end
+
+    # The session file's form: "from" only when there is one.
+    def to_file = { "subjects" => subjects, "from" => from }.compact
+  end
+end

data/lib/samagotchi/share_command.rb

@@ -93,6 +93,9 @@ module Samagotchi
       send(:"run_#{@sub || "invite"}", parsed.options, parsed.args)
     rescue SessionAccess::BadRequest => e
       usage_error(e.message)
+    rescue Web::Grants::Corrupt => e
+      error_line("#{command_name}: #{e.message}")
+      CLI::Exit::FAILED
     rescue ArgumentError => e
       error_line("#{command_name}: #{e.is_a?(Session::AmbiguousId) ? e.message : e.message.sub(/\ASession not found: /, "no session ")}")
       CLI::Exit::FAILED
@@ -189,8 +192,11 @@ module Samagotchi
                    "#{local(row.expires_at, "%Y-%m-%d %H:%M")} · cap #{money(row.cap)}")
       @stdout.puts(invitation.link)
       @stdout.puts("(shown once: chi keeps only its digest; chi share revoke #{id[0, 8]} #{row.id} ends it)")
+      if invitation.warning
+        error_line("#{command_name}: warning: #{invitation.warning} (#{@access.invocation.command("review --from #{id[0, 8]}")} starts one)")
+      end
       unless invitation.lan
-        @stdout.puts("chi web isn't on the LAN there (web.host: lan): this link opens on that machine only")
+        @stdout.puts("chi web isn't on the LAN there (web.host: lan): this link opens on that machine only, as the participant")
       end
       @stdout.puts(Web::QR.lines(invitation.link)) if @tty
     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)