samagotchi 0.107.0 → 0.109.0

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -5,6 +5,7 @@ require_relative "../kernel_loop"
 require_relative "../steer"
 require_relative "../tool_output_cut"
 require_relative "../tool_row_fields"
+require_relative "../turn_origin"
 require_relative "turn_notice"
 
 module Samagotchi
@@ -70,7 +71,7 @@ module Samagotchi
       # Whether the turn in progress is a participant's review turn (its
       # author): the owner's input queues behind it then (Bridge's POST /turn).
       def participant_turn?
-        @mutex.synchronize { !@turn.nil? && Steer.participant_author?(@turn[:author] || @turn.dig(:origin, :author)) }
+        @mutex.synchronize { !@turn.nil? && Steer.participant_author?(@turn[:author] || TurnOrigin.from(@turn[:origin])&.author) }
       end
 
       # The turn in progress as conversation messages, for a plugin's
@@ -382,7 +383,7 @@ module Samagotchi
       end
 
       def dequeue(origins)
-        ids = origins.filter_map { |origin| origin.is_a?(Hash) ? origin[:enqueued_id] : nil }
+        ids = origins.filter_map { |origin| TurnOrigin.from(origin)&.enqueued_id }
         @queued.reject! { |entry| ids.include?(entry[:enqueued_id]) } unless ids.empty?
       end
     end

data/lib/samagotchi/bridge.rb

@@ -22,9 +22,11 @@ require_relative "engine"
 require_relative "session_commands"
 require_relative "queued_command"
 require_relative "steer"
+require_relative "turn_origin"
 require_relative "participants"
 require_relative "image_store"
 require_relative "log"
+require_relative "proxy_trace"
 require_relative "version"
 require_relative "worker_sidecar"
 require_relative "relay_verifier"
@@ -119,6 +121,8 @@ module Samagotchi
       @connection_threads = []
       @stopped = false
       @mutex = Monitor.new
+      @proxied_log_mutex = Mutex.new
+      @proxied_logged_at = nil
       @open_streams = 0
       # Open streams by the client_id a stream named (`?client_id=`); web
       # tabs, through the `chi web` proxy, name none.
@@ -437,6 +441,10 @@ module Samagotchi
           break
         elsif browser_request?(headers)
           write_json(io, 403, nil, { error: "cross_origin", detail: "the bridge answers chi's own clients only" })
+        elsif proxied_request?(headers)
+          note_proxied_refused(request[:path])
+          write_json(io, 403, nil, { error: "proxied", detail: "the bridge answers chi's own clients on this machine, " \
+                                                               "never a request through a proxy" })
         elsif route.nil?
           write_json(io, 404, { "Allow" => "GET, POST" },
                      { error: "not_found", path: request[:path] })
@@ -523,6 +531,24 @@ module Samagotchi
     # no Sec-Fetch-Site. A browser page always sends one of them (another
     # website's text/plain POST needs no preflight), and a DNS-rebound page
     # also has a foreign Host. Headers are the raw ones, lowercased.
+    # A request through a proxy (an auth proxy forwarding every port, as a
+    # work pod's does) carries a trace chi's own clients never send
+    # (ProxyTrace: X-Forwarded-*, Forwarded, X-Real-IP, X-Auth-Request-*…,
+    # underscore twins too): refused, whoever signed in to the proxy. chi
+    # web's stream proxy forwards Last-Event-ID only (ProxyStreamBody).
+    def proxied_request?(headers) = headers.keys.any? { |name| ProxyTrace.header?(name) }
+
+    PROXIED_LOG_INTERVAL = 60.0
+
+    # At most once a minute: a scan through a forward would fill the log.
+    def note_proxied_refused(path)
+      now = monotonic_now
+      due = @proxied_log_mutex.synchronize do
+        (@proxied_logged_at.nil? || now - @proxied_logged_at >= PROXIED_LOG_INTERVAL).tap { |fresh| @proxied_logged_at = now if fresh }
+      end
+      Log.warn(:bridge, "proxied_refused", path: path) if due
+    end
+
     def browser_request?(headers)
       return true if headers.key?("origin")
       return true if headers.key?("sec-fetch-site") && headers["sec-fetch-site"].downcase != "none"
@@ -1032,14 +1058,14 @@ module Samagotchi
     # +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 = TurnOrigin.of(@accumulator.current_turn&.dig(:origin)).participant_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,
+      Participants.log(sid, :refused, state_dir: File.dirname(session_dir), participant: Steer.participant_id(author), what: what,
                                       reason: "not_permitted")
       [{}, 403, { error: "not_permitted", detail: Participants::NOT_PERMITTED }]
     end

data/lib/samagotchi/bundles/cost-cap/manifest.yml

@@ -1,12 +1,12 @@
 ---
 name: cost-cap
-version: 0.2.1
+version: 0.2.3
 scope: system
 description: "A per-session $ cap: at the cap the turn pauses on Continue (another cap's worth) / Stop, a warning at 80% goes to the user only; /cap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:28d632cd19117ef359acc6aa1c621081c14c018772b7fe1efd6284e346fea135
+  sha256: sha256:57362669f6b499fb70103a11eb6582e261b69103f51ee1ac36496a04717f5d9b
 # ctx.cost is new in chi 0.83.0; ask_user's effects: in the next chi
 requires_chi: ">= 0.92.0"
 # session_settings: as a mapping of keys to types is new

data/lib/samagotchi/bundles/cost-cap/plugin.rb

@@ -44,6 +44,7 @@ class Plugin
     @warned = nil          # [session id, cap] the share warning was given for
     @unknown_warned = nil  # the session id the "can't be enforced" notice was given for
     @unread_warned = nil   # the session id the "isn't a number" notice was given for
+    @corrupt_warned = nil  # the session id the "state file doesn't read" notice was given for
   end
 
   def register(chi)
@@ -104,6 +105,7 @@ class Plugin
   def check(ctx)
     resolved = resolve(ctx)
     unreadable(ctx, resolved)
+    corrupt(ctx, resolved)
     cap = resolved[:cap]
     return unless cap
 
@@ -140,10 +142,23 @@ class Plugin
     return if bad.nil? || bad.empty? || !first_time?(:@unread_warned, resolved[:session])
 
     named = bad.map { |key, value| "#{key}: #{value.inspect}" }.join(" and ")
-    used = resolved[:cap] ? "using #{resolved[:key]}: (#{money(resolved[:cap])})" : "no cap"
-    ctx.notify("cost-cap: #{named} #{bad.size == 1 ? "isn't" : "aren't"} a number or off; #{used}", level: :warn)
+    ctx.notify("cost-cap: #{named} #{bad.size == 1 ? "isn't" : "aren't"} a number or off; #{using(resolved)}",
+               level: :warn)
   end
 
+  # Once per session: a state file that is there but doesn't read (not
+  # JSON, or not a mapping) holds no /cap cap, so the settings' is used;
+  # said rather than a /cap cap silently gone.
+  def corrupt(ctx, resolved)
+    path = resolved[:corrupt]
+    return unless path && first_time?(:@corrupt_warned, resolved[:session])
+
+    ctx.notify("cost-cap: #{path} doesn't read, its /cap cap is ignored; #{using(resolved)}", level: :warn)
+  end
+
+  # "using default: ($5.00)", or "no cap".
+  def using(resolved) = resolved[:cap] ? "using #{resolved[:key]}: (#{money(resolved[:cap])})" : "no cap"
+
   def at_cap(ctx, resolved, cost)
     cap = resolved[:cap]
     raised = raised_cap(cap, resolved[:step] || cap, cost.total)
@@ -222,20 +237,29 @@ class Plugin
     cached = @mutex.synchronize { @resolved }
     return cached if cached && cached[:session] == session
 
-    resolved = { session: session, **(state(ctx, session) || configured(ctx)) }
+    saved, corrupt = state(ctx, session)
+    resolved = { session: session, **(saved || configured(ctx)), corrupt: corrupt }
     @mutex.synchronize { @resolved = resolved }
   end
 
+  # The state file's cap and step ({cap:, step:}), nil without one (or
+  # one without a "cap"), and the file's path when it is there but
+  # doesn't read (logged; the user is told by #corrupt), else nil.
   def state(ctx, session)
-    return nil unless session
+    return [nil, nil] unless session
 
-    saved = JSON.parse(File.read(state_path(ctx, session)))
-    return nil unless saved.is_a?(Hash) && saved.key?("cap")
+    path = state_path(ctx, session)
+    saved = JSON.parse(File.read(path))
+    raise JSON::ParserError, "not a JSON object" unless saved.is_a?(Hash)
+    return [nil, nil] unless saved.key?("cap")
 
     cap = self.class.amount(saved["cap"])
-    { cap: cap, step: self.class.amount(saved["step"]) || cap }
-  rescue Errno::ENOENT, JSON::ParserError
-    nil
+    [{ cap: cap, step: self.class.amount(saved["step"]) || cap }, nil]
+  rescue Errno::ENOENT
+    [nil, nil]
+  rescue JSON::ParserError => e
+    ctx.log.warn(:costcap_state_unreadable, path: path, error: e.message.to_s[0, 200])
+    [nil, path]
   end
 
   # The first of cap:, child: (a delegate's) and default: that is set and
@@ -259,14 +283,32 @@ class Plugin
     share.is_a?(Numeric) && share.positive? ? share : nil
   end
 
+  # A state file there that doesn't read (#state) is written over: logged
+  # and said, never a silent replace.
   def save(ctx, session, data)
     path = state_path(ctx, session)
     FileUtils.mkdir_p(File.dirname(path))
+    replacing = unreadable_file?(path)
     Samagotchi::AtomicFile.write(path, "#{JSON.generate(data)}\n")
+    replaced(ctx, path) if replacing
     cap = self.class.amount(data["cap"])
     @mutex.synchronize { @resolved = { session: session, cap: cap, step: self.class.amount(data["step"]) || cap } }
   end
 
+  # Whether +path+ is there but doesn't read (not JSON, or not a mapping).
+  def unreadable_file?(path)
+    !JSON.parse(File.read(path)).is_a?(Hash)
+  rescue Errno::ENOENT
+    false
+  rescue JSON::ParserError
+    true
+  end
+
+  def replaced(ctx, path)
+    ctx.log.warn(:costcap_state_replaced, path: path)
+    ctx.notify("cost-cap: #{path} didn't read; replaced with the new cap", level: :warn)
+  end
+
   def state_path(ctx, session) = File.join(ctx.data_dir, "sessions", "#{session.gsub(/[^A-Za-z0-9_.-]/, "_")}.json")
 
   def money(value) = self.class.money(value)

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.107.0
+version: 0.109.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:df3f8da539a9f5812f79e089c2c8b9894da6124a89654f292160046a6bb060da
   config_modification_protocol.md: sha256:ff4efccf2bdde453fc4e6741df8c18f78da78e353f6b1a5a64d0e7a631aea258
-  memory_guide.md: sha256:c48eea744db69e4f3e9bb415e9a03a8c78bbcaa1205ad3b1fb157a079f92d22e
+  memory_guide.md: sha256:dfb3982cf281bf7920d018ea65b68b5755f86d8bd1e03bab9db42393a94ec7e0
   delegated.md: sha256:a0d6ddcd4a8be06526d964898611775fd251cfd9d145a9d16afaccaa503597bd

data/lib/samagotchi/bundles/system/memory_guide.md

@@ -26,7 +26,7 @@ This memory teaches you (the agent) how to use Samagotchi memories — persisten
 - `name: "entry", scope: "system"|"project"` — scoped read.
 - `name: "a, b, c"` — comma-separated, concatenated with `\n\n---\n\n`.
 - `name: ""` (optionally with `scope`) — reads the index. Empty name with no scope returns both indexes concatenated (`Project memories:` / `System memories:`). Use this at start to discover what exists.
-- Returns `Error: memory not found: …` on miss — treat as missing, not fatal.
+- Returns `Error: memory not found: …` on miss — treat as missing, not fatal. A `Hint:` line after it means this project's memory folder looks orphaned (moved from another path); tell the user the folders it names, don't rename them yourself.
 
 ### `memory_write` — write/update entries
 

data/lib/samagotchi/bundles/work-cap/manifest.yml

@@ -1,12 +1,12 @@
 ---
 name: work-cap
-version: 0.1.1
+version: 0.1.3
 scope: system
 description: "A per-session work cap (tool calls, active minutes) across turns: at a cap the turn pauses on Continue (another cap's worth) / Stop with the session's totals, a warning at 80% goes to the user only; /workcap shows or sets it"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:f4ce7ea7f5801490a29e232c41c7bca2007c140d21f1a78bbfb60e6b6fd4f64b
+  sha256: sha256:3c93baec9ec20e147803311e1eb16d699dc169b52680374c1e6ff865a82204ee
 # ask_user's effects: are in chi 0.92.0; ctx.usage is new in the next chi
 requires_chi: ">= 0.100.0"
 # chi --set work-cap.tool_calls=400 / work-cap.minutes=60: the session's own caps, a number or off

data/lib/samagotchi/bundles/work-cap/plugin.rb

@@ -63,6 +63,7 @@ class Plugin
     @resolved = nil        # {session:, settings:, meters: {meter => {cap:, step:, key:}}, unreadable: {name => value}}
     @warned = {}           # meter => [session id, cap] the share warning was given for
     @unread_warned = nil   # the session id the "isn't a number" notice was given for
+    @corrupt_warned = nil  # the session id the "state file doesn't read" notice was given for
   end
 
   def register(chi)
@@ -126,6 +127,7 @@ class Plugin
   def check(ctx)
     resolved = resolve(ctx)
     unreadable(ctx, resolved)
+    corrupt(ctx, resolved)
     capped = resolved[:meters].select { |_meter, meter_cap| meter_cap[:cap] }
     return if capped.empty?
 
@@ -161,11 +163,26 @@ class Plugin
     return if bad.empty? || !first_time?(:@unread_warned, resolved[:session])
 
     named = bad.map { |key, value| "#{key}: #{value.inspect}" }.join(" and ")
+    ctx.notify("work-cap: #{named} #{bad.size == 1 ? "isn't" : "aren't"} a number or off; #{using(resolved)}",
+               level: :warn)
+  end
+
+  # Once per session: a state file that is there but doesn't read (not
+  # JSON, or not a mapping) holds no /workcap caps, so the settings' are
+  # used; said rather than a /workcap cap silently gone.
+  def corrupt(ctx, resolved)
+    path = resolved[:corrupt]
+    return unless path && first_time?(:@corrupt_warned, resolved[:session])
+
+    ctx.notify("work-cap: #{path} doesn't read, its /workcap caps are ignored; #{using(resolved)}", level: :warn)
+  end
+
+  # "using tool_calls: (400), minutes: (60)", or "no cap".
+  def using(resolved)
     used = resolved[:meters].values.filter_map do |meter_cap|
       "#{meter_cap[:key]}: (#{count(meter_cap[:cap])})" if meter_cap[:cap]
     end
-    using = used.empty? ? "no cap" : "using #{used.join(", ")}"
-    ctx.notify("work-cap: #{named} #{bad.size == 1 ? "isn't" : "aren't"} a number or off; #{using}", level: :warn)
+    used.empty? ? "no cap" : "using #{used.join(", ")}"
   end
 
   def at_cap(ctx, resolved, reached, usage, used)
@@ -280,29 +297,37 @@ class Plugin
     cached = @mutex.synchronize { @resolved }
     return cached if cached && cached[:session] == session && cached[:settings] == settings
 
-    saved = state(ctx, session)
+    saved, corrupt = state(ctx, session)
     configured = configured(ctx)
     meters = METERS.to_h { |meter| [meter, saved[meter] || configured[:meters][meter]] }
-    resolved = { session: session, settings: settings, meters: meters, unreadable: configured[:unreadable] }
+    resolved = { session: session, settings: settings, meters: meters, unreadable: configured[:unreadable],
+                 corrupt: corrupt }
     @mutex.synchronize { @resolved = resolved }
   end
 
-  # The state file's meters ({meter => {cap:, step:}}), {} without one.
+  # The state file's meters ({meter => {cap:, step:}}), {} without one,
+  # and the file's path when it is there but doesn't read (logged; the
+  # user is told by #corrupt), else nil.
   def state(ctx, session)
-    return {} unless session
+    return [{}, nil] unless session
 
-    saved = JSON.parse(File.read(state_path(ctx, session)))
-    return {} unless saved.is_a?(Hash)
+    path = state_path(ctx, session)
+    saved = JSON.parse(File.read(path))
+    raise JSON::ParserError, "not a JSON object" unless saved.is_a?(Hash)
 
-    METERS.each_with_object({}) do |meter, meters|
+    meters = METERS.each_with_object({}) do |meter, found|
       entry = saved[meter]
       next unless entry.is_a?(Hash) && entry.key?("cap")
 
       cap = self.class.amount(entry["cap"], meter)
-      meters[meter] = { cap: cap, step: self.class.amount(entry["step"], meter) || cap, key: "/workcap" }
+      found[meter] = { cap: cap, step: self.class.amount(entry["step"], meter) || cap, key: "/workcap" }
     end
-  rescue Errno::ENOENT, JSON::ParserError
-    {}
+    [meters, nil]
+  rescue Errno::ENOENT
+    [{}, nil]
+  rescue JSON::ParserError => e
+    ctx.log.warn(:workcap_state_unreadable, path: path, error: e.message.to_s[0, 200])
+    [{}, path]
   end
 
   # Per meter the first of its own value, child:'s (a delegate's) and
@@ -358,21 +383,32 @@ class Plugin
   end
 
   # Write one meter's cap into the session's state file (the other kept).
+  # One there that doesn't read (#state) is written over: logged and said,
+  # never a silent replace.
   def save_meter(ctx, session, meter, data)
     path = state_path(ctx, session)
     FileUtils.mkdir_p(File.dirname(path))
     saved = begin
       JSON.parse(File.read(path))
-    rescue Errno::ENOENT, JSON::ParserError
+    rescue Errno::ENOENT
       {}
+    rescue JSON::ParserError
+      nil
     end
-    saved = {} unless saved.is_a?(Hash)
+    replacing = !saved.is_a?(Hash)
+    saved = {} if replacing
     saved[meter] = data.transform_values { |value| whole(value) }
     Samagotchi::AtomicFile.write(path, "#{JSON.generate(saved)}\n")
+    replaced(ctx, path) if replacing
     # Resolved again at the next use, from the file now holding the meter.
     @mutex.synchronize { @resolved = nil }
   end
 
+  def replaced(ctx, path)
+    ctx.log.warn(:workcap_state_replaced, path: path)
+    ctx.notify("work-cap: #{path} didn't read; replaced with the new cap", level: :warn)
+  end
+
   # 800.0 as 800 (a whole cap is saved as an Integer), 2.5 as it is.
   def whole(value) = value.is_a?(Float) && value.finite? && value == value.to_i ? value.to_i : value
 

data/lib/samagotchi/child_reports.rb

@@ -7,6 +7,7 @@ require_relative "session"
 require_relative "session_inbox"
 require_relative "reply_wait"
 require_relative "steer"
+require_relative "turn_origin"
 require_relative "log"
 require_relative "config"
 require_relative "tools/delegate_wait"
@@ -138,7 +139,7 @@ module Samagotchi
       def initialize(relay: nil, **) = super
 
       def line(mark: nil) = Steer::Line.new(text: text, source: ChildReports::SOURCE, mark: mark)
-      def origin = { client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}" }
+      def origin = TurnOrigin.new(client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}")
     end
 
     # @param predecessor [String, nil] the link this session continues

data/lib/samagotchi/cli/parent_wait.rb

@@ -96,7 +96,7 @@ module Samagotchi
           @stdout.flush
           @reported = true
         end
-        error_line("#{command_name}: still running: #{@access.invocation.shows(id)}")
+        error_line("#{command_name}: still running: #{ParentReport.still_running_hint(id, report_turn_id, via: @access.invocation)}")
         Exit::INTERRUPTED
       rescue ArgumentError
         error_line("#{command_name}: the session is gone (deleted while waiting)")

data/lib/samagotchi/config.rb

@@ -316,6 +316,10 @@ module Samagotchi
       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),
+      # chi web behind an auth proxy (Web::PublicUrl, docs/configuration.md "Behind an auth proxy").
+      Entry.new(key: "web.public_url",           yaml_path: %w[web public_url],           type: :string, default: nil,  expose: %i[env config], lifecycle: :web_start),
+      Entry.new(key: "web.proxy.identity_header", yaml_path: %w[web proxy identity_header], type: :string, default: nil, expose: %i[env config], lifecycle: :web_start),
+      Entry.new(key: "web.proxy.owner",          yaml_path: %w[web proxy owner],          type: :string, default: nil,  expose: %i[env config], lifecycle: :web_start),
 
       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),

data/lib/samagotchi/context_sources.rb

@@ -359,12 +359,7 @@ module Samagotchi
     def project_location_for(project_root, state_dir: nil)
       return nil if project_root.to_s.empty?
 
-      project_location(project_key_of(project_root), state_dir: state_dir)
-    end
-
-    # MemoryPaths.project_key for a root already resolved.
-    def project_key_of(root)
-      "#{File.basename(root)}_#{Digest::MD5.hexdigest(root)[0..7]}"
+      project_location(MemoryPaths.key_for_root(project_root), state_dir: state_dir)
     end
 
     # A session's sources: its own, then the project's it doesn't shadow

data/lib/samagotchi/continue_offer.rb

@@ -4,6 +4,7 @@ require "time"
 require_relative "last_turn"
 require_relative "log"
 require_relative "steer"
+require_relative "turn_origin"
 
 module Samagotchi
   # A session worker's continue offer: what it announces when a turn runs out
@@ -71,6 +72,7 @@ module Samagotchi
 
     # A prompt (or a reminder turn) taken while a continue is offered
     # replaces the answer (D2): the offer goes, the partial turn stays.
+    # @param origin [TurnOrigin] the taken turn's
     def drop(origin)
       return unless awaiting?
 
@@ -78,7 +80,7 @@ module Samagotchi
       close("dropped")
       @engine.synchronize_events do
         @turn_flow.drop_offer!
-        @engine.announce(type: :continue_resolved, decision: "dropped", client_id: origin&.dig(:client_id))
+        @engine.announce(type: :continue_resolved, decision: "dropped", client_id: origin.client_id)
       end
       @engine.record_activity
     end
@@ -149,7 +151,7 @@ module Samagotchi
       offer = @turn_flow.offer
       resume_from = @turn_flow.resume_from
       enqueued_id = offer_turn_id
-      author = Steer.sender_author(@engine.session&.last_turn&.author)
+      author = @engine.session&.last_turn&.participant_author
       close("answered")
       if author && (reason = @participant_refused.call(author))
         @continue_steer = nil
@@ -166,7 +168,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, author: author }.compact
+        origin = TurnOrigin.new(client_id: command.client_id, enqueued_id: enqueued_id, author: author)
         @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
@@ -192,7 +194,7 @@ module Samagotchi
     private
 
     def refusal_of_offer_author
-      author = Steer.sender_author(@engine.session&.last_turn&.author)
+      author = @engine.session&.last_turn&.participant_author
       author && @participant_refused.call(author)
     end
 
@@ -204,11 +206,11 @@ module Samagotchi
     # participant turns go on). The question goes with the next close.
     # Called with the event log held.
     def refuse_continue(reason, command)
-      author = @engine.session&.last_turn&.author
+      author = @engine.session&.last_turn&.participant_author
       enqueued_id = offer_turn_id
       @engine.announce(type: :continue_resolved, decision: "refused", reason: reason.to_s, client_id: command.client_id)
       @engine.announce(type: :hook_notice, hook: "participants", level: :warn, between_turns: true,
-                       text: format(REFUSED_NOTICE, who: author.to_s.delete_prefix("p:"), reason: REFUSED_WHY.fetch(reason.to_s, reason.to_s)))
+                       text: format(REFUSED_NOTICE, who: Steer.participant_id(author), reason: REFUSED_WHY.fetch(reason.to_s, reason.to_s)))
       @turn_flow.abort_continue!
       session = @engine.session
       session.last_turn = LastTurn.new(outcome: NOT_CONTINUED, ended_at: Time.now.iso8601(3), enqueued_id: enqueued_id) if session