samagotchi 0.86.0 → 0.88.0

data/lib/samagotchi/child_reports.rb

@@ -130,7 +130,13 @@ module Samagotchi
     # (DelegateWait.finish, its report variant), the cursor it moves the child to,
     # and the cursor it was read from (a commit after the model moved it
     # itself, with delegate_result, leaves it alone).
-    Report = Data.define(:child_id, :text, :before, :after, :rings, :claim_id) do
+    # +relay+: the child's question when it goes to the parent's user
+    # (Tools::DelegateRelay.relay?): #resolve relays it on the turn thread
+    # and gives the report its outcome line; +text+ is the question's
+    # report until then (what a parent with no relay gets).
+    Report = Data.define(:child_id, :text, :before, :after, :rings, :claim_id, :relay) do
+      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]}" }
     end
@@ -146,14 +152,19 @@ module Samagotchi
       Tools::DelegateCursors.clear_report_claims(@session_id, state_dir: @state_dir)
       # child id → the Report this turn took for it (rings merged).
       @taken = {}
+      # child id → the question id whose relay card a Stop closed (#hold_back).
+      @held = {}
     end
 
+    # The user's next input: questions held back after a Stop are offered again.
+    def release_holds = @held.clear
+
     # Whether a ring this turn hasn't taken waits (the idle loop's check).
     def waiting?
       return false if ChildRing.mode == "off"
 
       taken = taken_rings
-      ring_files.any? { |file| !taken.include?(file) }
+      ring_files.any? { |file| !taken.include?(file) && !held?(file) }
     end
 
     # The reports for rings this turn hasn't taken yet, recorded as taken.
@@ -164,7 +175,7 @@ module Samagotchi
       return [] if ChildRing.mode == "off"
 
       taken = taken_rings
-      fresh = ring_files.reject { |file| taken.include?(file) }
+      fresh = ring_files.reject { |file| taken.include?(file) || held?(file) }
       by_child = fresh.group_by { |file| SessionInbox.read_ring(file)&.dig(:child_id) }
       by_child.filter_map do |child_id, rings|
         report = child_id && report_for(child_id, rings)
@@ -207,8 +218,79 @@ module Samagotchi
       @taken = {}
     end
 
+    # A report whose question goes to the parent's user, settled: relayed
+    # through +relay+ (DelegateRelay.call: blocks until the card is
+    # answered, closed or the turn stopped) and given the outcome line as
+    # its text. Runs on the turn thread, before the boundary merges it.
+    # The child's question answered since the ring was taken opens no card;
+    # nor does one already answered on a relay (RelayDesk#settled?).
+    # @param relay [#open_question, #relay_desk, nil] Engine#relay_peer;
+    #   nil: the report's question text, as without P4's relay
+    # @return [Report, nil] nil when the parent's turn was stopped with the
+    #   card open: the report is released (its ring and the cursor stay), so
+    #   the next turn offers it again
+    def resolve(report, relay:)
+      return report unless report.relay
+      return report.with(relay: nil) unless relay
+
+      question = report.relay
+      what = question.header.to_s.empty? ? question.hook.to_s : question.header.to_s
+      line = if Session.load(report.child_id, state_dir: @state_dir).pending_question&.id.to_s != question.id.to_s
+               Tools::DelegateRelay.line(what, "answered on the child", hook: true)
+             elsif relay.relay_desk.settled?(report.child_id, question.id)
+               Tools::DelegateRelay.line(what, "answered on a relay already; it waits for the user on the child", hook: true)
+             else
+               outcome = Tools::DelegateRelay.call(report.child_id, question, relay: relay, state_dir: @state_dir)
+               return hold_back(report) if outcome.stopped
+
+               outcome.line
+             end
+      resolved = report.with(relay: nil, text: relayed_text(report.child_id, line))
+      @taken[report.child_id] = resolved if @taken[report.child_id]&.claim_id == report.claim_id
+      resolved
+    rescue ArgumentError => e
+      # The child is gone (or a bug): its question's report, as without a relay.
+      Log.info(:worker, "delegate_relay_unresolved", child: report.child_id[0, 8], error: e.message)
+      report.with(relay: nil)
+    end
+
+    # A relay report the parent's turn stopped on, or one behind it in the
+    # same take: released (its ring and the cursor stay) and held back, so
+    # no wake turn offers that question again until the user's next input
+    # (#release_holds); other children's rings go on.
+    # @return [nil]
+    def hold_back(report)
+      @held[report.child_id] = report.relay.id.to_s
+      release_report(report)
+    end
+
     private
 
+    # A ring of a child whose held-back question still waits.
+    def held?(file)
+      child_id = SessionInbox.read_ring(file)&.dig(:child_id)
+      question_id = @held[child_id] or return false
+      Session.load(child_id, state_dir: @state_dir).pending_question&.id.to_s == question_id
+    rescue ArgumentError
+      false
+    end
+
+    # A relayed question's report: the outcome line, then the next reply's
+    # promise (as a report's question text ends).
+    def relayed_text(child_id, line)
+      Tools::DelegateWait.result(child_id, "question", "#{line}\n#{Tools::DelegateWait::REPORT_NEXT_REPLY}")
+    end
+
+    # One taken report back: its cursor claim goes, its rings stay untaken.
+    # @return [nil]
+    def release_report(report)
+      @taken.delete(report.child_id)
+      Tools::DelegateCursors.update(@session_id, report.child_id, state_dir: @state_dir) do |cursor|
+        cursor.report_claim&.fetch("id", nil) == report.claim_id ? cursor.with(report_claim: nil) : cursor
+      end
+      nil
+    end
+
     def taken_rings
       @taken.values.flat_map(&:rings)
     end
@@ -260,22 +342,33 @@ module Samagotchi
       # a later wait on it would repeat its reply.
       after = after.with(report_claim: claim)
       text = Tools::DelegateWait.finish(wait, child_id, timeout: 0, report: true)
-      Report.new(child_id: child_id, text: text, before: before, after: after, rings: rings, claim_id: claim_id)
+      Report.new(child_id: child_id, text: text, before: before, after: after, rings: rings, claim_id: claim_id,
+                 relay: relay?(wait) ? wait.question : nil)
     rescue ArgumentError
       nil # the child is gone
     end
 
     # A reply, a turn that left none, a crash, or a question the parent's
-    # model decides (its own ask_user_question, the step-limit continue).
-    # Approvals and hooks' questions are the user's, on the child's card.
+    # model decides (its own ask_user_question, the step-limit continue, a
+    # hook's question). Approvals are the user's (the relay, while the
+    # parent waits; else on the child's card).
     def reportable?(wait)
       case wait.status
       when :done, :no_reply, :error then true
-      when :waiting_for_answer then [nil, "", "continue"].include?(wait.question&.kind&.to_s)
+      when :waiting_for_answer then REPORTED_KINDS.include?(wait.question&.kind&.to_s)
       else false
       end
     end
 
+    REPORTED_KINDS = [nil, "", "continue", Tools::DelegateRelay::HOOK_KIND].freeze
+
+    # Whether the child's question goes to this parent's user rather than
+    # its model (Tools::DelegateRelay.relay?, under the child's strategy).
+    def relay?(wait)
+      wait.status == :waiting_for_answer && wait.question.kind.to_s == Tools::DelegateRelay::HOOK_KIND &&
+        Tools::DelegateRelay.relay?(wait.question, strategy: Guardrails::ParentPolicy.for_session(wait.session))
+    end
+
     def delete_rings(rings)
       rings.each { |file| FileUtils.rm_f(file) }
     end

data/lib/samagotchi/cli/parent_wait.rb

@@ -76,8 +76,10 @@ module Samagotchi
         result.turn_id = report_turn_id if report_turn_id && !report_turn_id.to_s.empty?
         result.text = result.text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
         @reported = true
+        # What a parent may pick there: config.yml tightened by the session's own.
+        strategy = ParentReport.strategy_for(id, state_dir: @state_dir)
         ParentReport.report(result, session_id: id, stdout: @stdout, stderr: @stderr, command: command_name,
-                                    json: @json, timeout: timeout, extra: report_extra)
+                                    json: @json, timeout: timeout, extra: report_extra, strategy: strategy)
       rescue Interrupt
         if @json
           @stdout.puts(ParentReport.json_line(ReplyWait::Result.new(status: :canceled, turn_id: report_turn_id), session_id: id,

data/lib/samagotchi/guardrails/parent_policy.rb

@@ -17,7 +17,9 @@ module Samagotchi
     # but eager parent, not a security boundary.
     #
     # Strategies (guardrails.parent_answers, config.yml only): hard = answer
-    # and deny; standard = + spend; soft (the default) = + permit.
+    # and deny; standard = + spend; soft (the default) = + permit. A session
+    # may carry its own, stricter one (Session#parent_answers): config.yml
+    # is the ceiling (#effective).
     #
     # Effects: answer (an untagged option), deny, spend (more time and
     # tokens: Continue), permit (one call: Allow once), permit_wide (more
@@ -45,16 +47,23 @@ module Samagotchi
       CONTINUE_QUESTION = PendingQuestion.new(kind: CONTINUE_KIND, options: [CONTINUE, STOP], effects: [SPEND, DENY])
 
       KEY = "guardrails.parent_answers"
+      # A session's own value (Session#parent_answers): it may only tighten KEY.
+      SESSION_KEY = "parent_answers"
       HARD = "hard"
       STANDARD = "standard"
       SOFT = "soft"
 
-      # A strategy: its name and the effects a parent may pick under it.
-      Strategy = Data.define(:name, :allowed) do
+      # A strategy: its name, the effects a parent may pick under it, and
+      # where it comes from: :config (config.yml's) or :session (a
+      # session's own, stricter one: #effective).
+      Strategy = Data.define(:name, :allowed, :origin) do
+        def initialize(name:, allowed:, origin: :config) = super
+
         def allow?(effect) = allowed.include?(effect.to_s)
 
-        # How a refusal names the setting: "guardrails.parent_answers: hard".
-        def label = "#{KEY}: #{name}"
+        # How a refusal names the setting: "guardrails.parent_answers: hard",
+        # or "parent_answers: hard (this session)" when the session's binds.
+        def label = origin == :session ? "#{SESSION_KEY}: #{name} (this session)" : "#{KEY}: #{name}"
       end
 
       STRATEGIES = {
@@ -74,6 +83,73 @@ module Samagotchi
       # @return [Strategy]
       def strategy(name) = STRATEGIES.fetch(name.to_s, STRATEGIES[HARD])
 
+      # Strictest first: a session's own level may only move left of
+      # config.yml's.
+      ORDER = [HARD, STANDARD, SOFT].freeze
+      # A session value that means "none of its own" (config's).
+      UNSET = "default"
+
+      # The stricter of two strategies, by name; a tie keeps +a+.
+      # @return [Strategy]
+      def stricter(a, b) = ORDER.index(b.name) < ORDER.index(a.name) ? b : a
+
+      # A session's own value as a level: nil when it has none (nil, "",
+      # "default"), the level, or hard for anything else (a hand-edited
+      # file: the strictest, as config's invalid value; not logged, as this
+      # is read on every parent answer).
+      # @return [String, nil]
+      def session_level(value)
+        word = value.to_s.strip.downcase
+        return nil if word.empty? || word == UNSET
+
+        STRATEGIES.key?(word) ? word : HARD
+      end
+
+      # Whether a session's own value is set but not a level (a hand-edited
+      # file: read as hard); the worker says so once when it loads.
+      def unknown_level?(value)
+        word = value.to_s.strip.downcase
+        !word.empty? && word != UNSET && !STRATEGIES.key?(word)
+      end
+
+      # What a parent may answer on a session whose own value is
+      # +session_value+: config.yml's (+config+) unless the session's is
+      # stricter. Config's own object when it binds, so its label stays.
+      # @return [Strategy]
+      def effective(session_value, config: current)
+        level = session_level(session_value)
+        return config if level.nil?
+
+        own = STRATEGIES[level]
+        stricter(config, own).equal?(config) ? config : own.with(origin: :session)
+      end
+
+      # Why a session's own +value+ doesn't apply: "soft is looser than
+      # config.yml's guardrails.parent_answers: standard; standard applies";
+      # nil when it applies (or is none).
+      # @return [String, nil]
+      def capped_note(value, config: current)
+        level = session_level(value)
+        return nil if level.nil? || effective(level, config: config).name == level
+
+        "#{level} is looser than config.yml's #{config.label}; #{config.name} applies"
+      end
+
+      # #effective with +session+'s own value (a Session; nil: config's).
+      # @return [Strategy]
+      def for_session(session) = effective(session&.parent_answers)
+
+      # Whether setting a session's value +from+ → +to+ loosens it: unset
+      # (config's) is the loosest, an invalid value hard. Only the user
+      # loosens (/parent-answers in a UI).
+      def looser?(from, to) = session_rank(to) > session_rank(from)
+
+      # hard 0, standard 1, soft 2, unset 3.
+      def session_rank(value)
+        level = session_level(value)
+        level.nil? ? ORDER.size : ORDER.index(level)
+      end
+
       # @return [Array<String>] the effects +strategy+ lets a parent pick
       def allowed_effects(strategy) = strategy.allowed
 
@@ -174,6 +250,19 @@ module Samagotchi
         end
       end
 
+      # Whether a parent may usefully answer +pending+ under +strategy+:
+      # some option it may pick is not a deny (free text alone is a deny
+      # with a reason). A delegate's question it may is reported to the
+      # parent's model; one it may not goes to the parent's user
+      # (Tools::DelegateRelay.relay?). Who may answer what stays #refusal's.
+      def parent_decides?(pending, strategy:)
+        deny = deny_labels(pending)
+        allowed_options(pending, strategy: strategy).any? { |label| !deny.include?(label) }
+      end
+
+      # The deny-tagged options' labels.
+      def deny_labels(pending) = Array(pending.options).zip(effects_of(pending)).filter_map { |label, tag| label.to_s if tag == DENY }
+
       # The question's deny-tagged option's label, or nil.
       def deny_label(pending)
         index = effects_of(pending).index(DENY)

data/lib/samagotchi/parent_answers_command.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "guardrails/parent_policy"
+
+module Samagotchi
+  # /parent-answers, the session's own guardrails.parent_answers
+  # (Session#parent_answers): with no argument, the level that applies, the
+  # session's own and config.yml's; `/parent-answers LEVEL` (hard, standard,
+  # soft) or `default` (none of its own) sets it, saved at once, for the next
+  # answer a parent gives. It may only tighten config.yml's
+  # (Guardrails::ParentPolicy.effective). Tightening goes from anyone;
+  # loosening (toward soft, or default) only from a user at a UI: the REPL,
+  # an attached TUI, the web (+user_ui+). A parent agent's line (chi send,
+  # a piped or marked attach, a delegate's follow-up) is refused.
+  class ParentAnswersCommand
+    NAME = "/parent-answers"
+    USAGE = "usage: #{NAME} [hard|standard|soft|default]".freeze
+    REFUSED = "loosening parent_answers is the user's: #{NAME} in chi --attach, the REPL or the web " \
+              "(not chi send or a parent agent)".freeze
+
+    # What +args+ (the text after the name) asks for.
+    # @return [Array] [:show], [:set, level or nil (default)] or [:usage]
+    def self.parse(args)
+      words = args.to_s.split
+      return [:show] if words.empty?
+      return [:usage] if words.size > 1
+
+      word = words.first.downcase
+      return [:set, nil] if word == Guardrails::ParentPolicy::UNSET
+
+      Guardrails::ParentPolicy::ORDER.include?(word) ? [:set, word] : [:usage]
+    end
+
+    # Whether the command line +line+ loosens a session whose own value is
+    # +current+ (chi send's early refusal, before it sends the line).
+    def self.loosens?(line, current)
+      kind, value = parse(line.to_s.strip.delete_prefix(NAME))
+      kind == :set && Guardrails::ParentPolicy.looser?(current, value)
+    end
+
+    # @param engine [Engine] #session
+    # @param save [#call] saves the session after a change
+    def initialize(engine:, save:)
+      @engine = engine
+      @save = save
+    end
+
+    # @param args [String] what follows /parent-answers
+    # @param user_ui [Boolean] a user at a UI typed it: it may loosen
+    # @return [Array(String, Boolean, Symbol)] the reply, whether the
+    #   session's value changed, and :ok or :error
+    def run(args, user_ui:)
+      session = @engine.session or return ["no session yet", false, :error]
+      kind, value = self.class.parse(args)
+      return [USAGE, false, :error] if kind == :usage
+      return [listing(session), false, :ok] if kind == :show
+      return ["#{listing(session)}\n(no change)", false, :ok] if value == session.parent_answers
+      return [REFUSED, false, :error] if Guardrails::ParentPolicy.looser?(session.parent_answers, value) && !user_ui
+
+      session.parent_answers = value
+      @save.call(session)
+      capped = Guardrails::ParentPolicy.capped_note(value)
+      [[listing(session), ("(#{capped})" if capped)].compact.join("\n"), true, :ok]
+    end
+
+    private
+
+    # "parent answers: standard (this session: standard; config.yml
+    # guardrails.parent_answers: soft)"
+    def listing(session)
+      config = Guardrails::ParentPolicy.current
+      effective = Guardrails::ParentPolicy.for_session(session)
+      own = session.parent_answers || "none"
+      # A hand-edited value that isn't a level: fail-closed, said here.
+      own = "#{own} (unreadable value, read as hard)" if session.parent_answers &&
+                                                         !Guardrails::ParentPolicy::ORDER.include?(session.parent_answers)
+      "parent answers: #{effective.name} (this session: #{own}; config.yml #{config.label})"
+    end
+  end
+end

data/lib/samagotchi/parent_report.rb

@@ -5,6 +5,7 @@ require "json"
 
 require_relative "cli/exit"
 require_relative "pending_question"
+require_relative "session"
 require_relative "guardrails/parent_policy"
 
 module Samagotchi
@@ -77,18 +78,20 @@ module Samagotchi
     # @param extra [Hash] more keys for the object (chi answer's
     #   answered_here: false)
     # @return [Hash] the --format json object
-    def json(result, session_id:, timeout: nil, extra: {})
+    # @param strategy [Guardrails::ParentPolicy::Strategy, nil] what a parent
+    #   may pick on the waited-for session (#strategy_for); nil: config.yml's
+    def json(result, session_id:, timeout: nil, extra: {}, strategy: nil)
       report = { status: status(result), session_id: session_id }
       report[:turn_id] = result.turn_id unless result.turn_id.to_s.empty?
       case report[:status]
       when "answered" then report[:text] = result.text.to_s
       when "question"
-        question = question(result.question)
+        question = question(result.question, strategy: strategy)
         report[:question] = question
         report[:answer_with] = answer_with(session_id, question)
       else
         report.merge!(stop_facts(result))
-        report[:detail] = detail(result, session_id: session_id, timeout: timeout)
+        report[:detail] = detail(result, session_id: session_id, timeout: timeout, strategy: strategy)
       end
       report.merge(extra)
     end
@@ -106,8 +109,8 @@ module Samagotchi
     end
 
     # @return [String] the JSON object as one line
-    def json_line(result, session_id:, timeout: nil, extra: {})
-      JSON.generate(json(result, session_id: session_id, timeout: timeout, extra: extra))
+    def json_line(result, session_id:, timeout: nil, extra: {}, strategy: nil)
+      JSON.generate(json(result, session_id: session_id, timeout: timeout, extra: extra, strategy: strategy))
     end
 
     # Print a wait's end the way the commands do: the JSON object on
@@ -116,17 +119,17 @@ module Samagotchi
     # @param command [String] "chi send", "chi answer"
     # @param extra [Hash] more keys for the JSON object (#json)
     # @return [Integer] the exit status
-    def report(result, session_id:, stdout:, stderr:, command:, json: false, timeout: nil, extra: {})
+    def report(result, session_id:, stdout:, stderr:, command:, json: false, timeout: nil, extra: {}, strategy: nil)
       if json
-        stdout.puts(json_line(result, session_id: session_id, timeout: timeout, extra: extra))
+        stdout.puts(json_line(result, session_id: session_id, timeout: timeout, extra: extra, strategy: strategy))
       elsif result.status == :done
         stdout.puts(result.text)
       else
         stdout.flush
         text = if result.status == :waiting_for_answer
-                 question_text(result.question, session_id: session_id)
+                 question_text(result.question, session_id: session_id, strategy: strategy)
                else
-                 "#{detail(result, session_id: session_id, timeout: timeout, turn_id: result.turn_id)}\n"
+                 "#{detail(result, session_id: session_id, timeout: timeout, turn_id: result.turn_id, strategy: strategy)}\n"
                end
         stderr.print("#{command}: #{text}")
       end
@@ -146,14 +149,14 @@ module Samagotchi
     # kind is "question" for the model's own (the desk stores none),
     # "hook", "approval" or "continue" (the step-limit question, with the
     # turn's limit). allowed_options: the options a parent may pick, by
-    # this process's guardrails.parent_answers (Guardrails::ParentPolicy),
-    # when that is not all of them.
+    # +strategy+ (nil: this process's guardrails.parent_answers;
+    # Guardrails::ParentPolicy), when that is not all of them.
     # @return [Hash]
-    def question(pending)
+    def question(pending, strategy: nil)
       pending = PendingQuestion.from_file(pending) || PendingQuestion.new
       approval = pending.approval.is_a?(Hash) ? symbolize(pending.approval) : nil
       options = Array(pending.options).map(&:to_s)
-      allowed = allowed_options(pending)
+      allowed = allowed_options(pending, strategy: strategy)
       {
         id: pending.id.to_s,
         kind: (pending.kind || "question").to_s,
@@ -189,33 +192,49 @@ module Samagotchi
     DENY_AND_TELL = "deny it, and tell your user"
 
     # The labels a parent may pick on +pending+ (a PendingQuestion, or a
-    # Hash with its fields) by this process's strategy.
+    # Hash with its fields) by +strategy+ (nil: this process's).
     # @return [Array<String>]
-    def allowed_options(pending)
+    def allowed_options(pending, strategy: nil)
       pending = PendingQuestion.from_file(pending) || PendingQuestion.new
-      Guardrails::ParentPolicy.allowed_options(pending, strategy: Guardrails::ParentPolicy.current)
+      Guardrails::ParentPolicy.allowed_options(pending, strategy: policy(strategy))
     end
 
+    # What a parent may pick on the session +session_id+: config.yml's
+    # level tightened by the session file's own parent_answers
+    # (Guardrails::ParentPolicy.for_session); config.yml's when there is no
+    # such session, hard (the strictest) when its file can't be read.
+    # @return [Guardrails::ParentPolicy::Strategy]
+    def strategy_for(session_id, state_dir:)
+      return Guardrails::ParentPolicy.current unless Session.exist?(session_id, state_dir: state_dir)
+
+      Guardrails::ParentPolicy.for_session(Session.load(session_id, state_dir: state_dir))
+    rescue ArgumentError, KeyError, TypeError, NoMethodError, SystemCallError, JSON::ParserError
+      Guardrails::ParentPolicy.strategy(Guardrails::ParentPolicy::HARD)
+    end
+
+    # +strategy+, or this process's config.yml's.
+    def policy(strategy) = strategy || Guardrails::ParentPolicy.current
+
     # An approval's options a parent may allow (Allow once under soft).
-    def allowed_allows(question)
-      question = question(question) unless question.is_a?(Hash) && question.key?(:text)
+    def allowed_allows(question, strategy: nil)
+      question = question(question, strategy: strategy) unless question.is_a?(Hash) && question.key?(:text)
       deny = Guardrails::Approval::DENY
       question.fetch(:allowed_options, question[:options]).reject { |label| label == deny }
     end
 
     # What a parent does with an approval: deny it and tell its user, or
     # give the Allow once its strategy lets it.
-    def approval_advice(question)
-      allows = allowed_allows(question)
+    def approval_advice(question, strategy: nil)
+      allows = allowed_allows(question, strategy: strategy)
       return DENY_AND_TELL if allows.empty?
 
-      "#{allows.join(" or ")} is yours to give (#{Guardrails::ParentPolicy.current.label}); " \
+      "#{allows.join(" or ")} is yours to give (#{policy(strategy).label}); " \
         "anything wider is up to your user: #{DENY_AND_TELL}"
     end
 
     # Whether a parent may answer Continue to a step-limit question.
-    def may_continue?(question)
-      question = question(question) unless question.is_a?(Hash) && question.key?(:text)
+    def may_continue?(question, strategy: nil)
+      question = question(question, strategy: strategy) unless question.is_a?(Hash) && question.key?(:text)
       question.fetch(:allowed_options, question[:options]).include?(Guardrails::ParentPolicy::CONTINUE)
     end
 
@@ -252,23 +271,23 @@ module Samagotchi
     end
 
     # What a wait that ended without an answer says, one line.
-    def detail(result, session_id:, timeout: nil, turn_id: nil)
+    def detail(result, session_id:, timeout: nil, turn_id: nil, strategy: nil)
       attach = "chi --attach #{session_id}"
       case result.status
       when :waiting_for_answer
-        q = question(result.question)
+        q = question(result.question, strategy: strategy)
         if approval?(q)
-          "waiting for an approval: #{first_line(q[:text])}; #{approval_advice(q)}"
+          "waiting for an approval: #{first_line(q[:text])}; #{approval_advice(q, strategy: strategy)}"
         elsif continue?(q) && !may_continue?(q)
           "waiting at the step limit: #{first_line(q[:text])}; a parent may only stop it here " \
-            "(#{Guardrails::ParentPolicy.current.label}): #{stop_command(session_id, q)}, or tell your user it waits"
+            "(#{policy(strategy).label}): #{stop_command(session_id, q)}, or tell your user it waits"
         elsif continue?(q)
           "waiting at the step limit: #{first_line(q[:text])}; " \
             "answer Continue or Stop: chi answer #{session_id} --question #{q[:id]} --option Continue"
         else
           "waiting for an answer: #{first_line(q[:text])}; open it: #{attach} or the web"
         end
-      when :no_reply then "#{no_reply_line(result, session_id)}; #{attach} shows it"
+      when :no_reply then "#{no_reply_line(result, session_id, strategy: strategy)}; #{attach} shows it"
       when :error then "the worker failed: #{result.text}; #{attach} shows what happened"
       when :worker_gone then "the worker is gone; #{attach} shows what happened"
       when :stopped then "the session was stopped (chi sessions stop)"
@@ -282,8 +301,8 @@ module Samagotchi
     # The whole question for stderr: header, text, numbered options, what
     # else it takes, and the commands that answer it.
     # @return [String] lines, newline-terminated
-    def question_text(pending, session_id:)
-      q = question(pending)
+    def question_text(pending, session_id:, strategy: nil)
+      q = question(pending, strategy: strategy)
       lines = ["waiting for an answer (#{q[:kind]}): #{q[:header] || first_line(q[:text])}"]
       text_lines = q[:text].strip.lines.map(&:rstrip)
       text_lines = text_lines.drop(1) unless q[:header]
@@ -294,7 +313,7 @@ module Samagotchi
         if allows.empty?
           lines << "  allowing it is up to your user: #{DENY_AND_TELL}"
         else
-          lines << "  #{approval_advice(q)}"
+          lines << "  #{approval_advice(q, strategy: strategy)}"
           allows.each { |label| lines << "  allow: chi answer #{session_id} --question #{q[:id]} --option #{option_arg(label)}" }
         end
         lines << "  deny: #{answer_with(session_id, q)}"
@@ -303,7 +322,7 @@ module Samagotchi
         lines << if may_continue?(q)
                    "  continue: #{answer_with(session_id, q)}"
                  else
-                   "  continuing it is up to your user (#{Guardrails::ParentPolicy.current.label}): stop it, or tell your user it waits"
+                   "  continuing it is up to your user (#{policy(strategy).label}): stop it, or tell your user it waits"
                  end
         lines << "  stop: #{stop_command(session_id, q)} (the text is optional; the model reads it)"
         lines << "  #{message_drops(session_id)}"
@@ -319,7 +338,7 @@ module Samagotchi
       lines.map { |line| "#{line}\n" }.join
     end
 
-    def no_reply_line(result, session_id = nil)
+    def no_reply_line(result, session_id = nil, strategy: nil)
       case result.outcome
       when "failed" then failed_line(result)
       when "canceled"
@@ -330,7 +349,7 @@ module Samagotchi
       when "removed" then "the queued message was removed before it ran; no turn ran for it"
       when "exhausted"
         ran_out = "the turn ran out of iterations#{" (#{result.limit} steps)" if result.limit} before it answered"
-        strategy = Guardrails::ParentPolicy.current
+        strategy = policy(strategy)
         if strategy.allow?(Guardrails::ParentPolicy::SPEND)
           "#{ran_out}; chi send #{session_id} -m '/continue yes' continues it, a message drops it"
         else

data/lib/samagotchi/question_desk.rb

@@ -305,8 +305,9 @@ module Samagotchi
       fm = freeform.to_s.strip
       fm = nil if fm.empty?
       parent_agent = client_id.to_s == ClientId::CLI_ANSWER if parent_agent.nil?
-      # Read before the lock (config may touch the disk); this worker's own.
-      strategy = Guardrails::ParentPolicy.current if parent_agent
+      # Read before the lock (config may touch the disk); this worker's own
+      # config.yml, tightened by its session's own parent_answers.
+      strategy = Guardrails::ParentPolicy.for_session(@session_lookup.call) if parent_agent
       standing = nil
       answer = @lock.synchronize do
         pending = @pending