samagotchi 0.86.0 → 0.87.0

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

data/lib/samagotchi/send_command.rb

@@ -5,6 +5,7 @@ require_relative "delivery"
 require_relative "terminal_ui/formatting"
 require_relative "session"
 require_relative "session_commands"
+require_relative "parent_answers_command"
 require_relative "session_inbox"
 require_relative "session_manager"
 require_relative "bundle_session_settings"
@@ -43,7 +44,7 @@ module Samagotchi
 
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...
-             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [--set BUNDLE.KEY=VALUE]... [-m TEXT] [--image PATH]...
+             chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [--toolkit NAME] [--set BUNDLE.KEY=VALUE]... [--parent-answers LEVEL] [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [--model M] [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
@@ -95,6 +96,11 @@ module Samagotchi
                     manifest lists in session_settings:; 3, 2.5, true,
                     false and off are typed, the rest is text:
                     --set cost-cap.cap=3)
+        --parent-answers LEVEL
+                    (--new) what a parent agent may answer on its
+                    questions: hard, standard or soft, only stricter than
+                    config.yml's guardrails.parent_answers (a looser one
+                    warns; config.yml's applies)
         --wait      wait for the answer and print it (one session); the
                     other lines go to stderr. Exit 3: it waits for an
                     answer from you: the question, its options and the
@@ -153,6 +159,7 @@ module Samagotchi
       f.value "--tool", key: :tools, repeat: true
       f.value "--no-tool", key: :no_tools, repeat: true
       f.value "--set", key: :sets, repeat: true
+      f.value "--parent-answers", key: :parent_answers
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
       f.switch "--cut"
@@ -246,12 +253,21 @@ module Samagotchi
       end
 
       # A parent agent's /continue yes is chi answer --option Continue by
-      # another route: held to guardrails.parent_answers here, and marked
-      # as chi answer's (#client_id_for) so the worker checks it again.
-      if prompt && parent_continue?(prompt) && (refusal = Guardrails::ParentPolicy.continue_refusal)
+      # another route: held to guardrails.parent_answers (tightened by each
+      # target's own) here, and marked as chi answer's (#client_id_for) so
+      # the worker checks it again.
+      if prompt && parent_continue?(prompt) && (refusal = continue_refusal_for(options))
         @stderr.puts("chi send: #{refusal}")
         return CLI::Exit::FAILED
       end
+      # chi send never loosens a session's own parent_answers (only a user
+      # at a UI does: the worker refuses it too); refused before anything
+      # is sent. Tightening goes.
+      if prompt && SessionCommands.builtin_registry.lookup(prompt)&.id == :parent_answers &&
+         target_parent_answers(options).any? { |value| ParentAnswersCommand.loosens?(prompt, value) }
+        error_line("chi send: refused: #{ParentAnswersCommand::REFUSED}")
+        return CLI::Exit::FAILED
+      end
       # A file that is not there or not an image: a run-time failure (1),
       # reported in the --format json line too; --image itself was fine.
       return CLI::Exit::FAILED unless ingest_images(options[:images])
@@ -305,6 +321,7 @@ module Samagotchi
       TOOLKIT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") unless Array(options[key]).empty? }
       LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
       return usage_error("--set needs --new") unless Array(options[:sets]).empty?
+      return usage_error("--parent-answers needs --new") if options[:parent_answers]
       return usage_error("give session ids") if options[:ids].empty?
 
       options
@@ -324,10 +341,10 @@ module Samagotchi
         taken = [("--dir" if options[:dir])] +
                 LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] } + [("--thinking" if options[:thinking])] +
                 [("--toolkit" if options[:toolkit])] + TOOLKIT_FLAGS.filter_map { |key, flag| flag unless Array(options[key]).empty? } +
-                [("--set" unless Array(options[:sets]).empty?)]
+                [("--set" unless Array(options[:sets]).empty?), ("--parent-answers" if options[:parent_answers])]
         unless taken.compact.empty?
           return usage_error("--continues takes the previous session's folder, LLM context, thinking level, " \
-                             "toolkit and bundle settings; " \
+                             "toolkit, bundle settings and parent_answers; " \
                              "leave out #{taken.compact.join(", ")}")
         end
       end
@@ -347,6 +364,13 @@ module Samagotchi
 
         options[:thinking] = Thinking.session_level(word)
       end
+      if options[:parent_answers]
+        word = options[:parent_answers].strip.downcase
+        levels = Guardrails::ParentPolicy::ORDER
+        return usage_error("--parent-answers takes #{levels.join(", ")}, not #{options[:parent_answers]}") unless levels.include?(word)
+
+        options[:parent_answers] = word
+      end
       toolkit = Toolkit.from_flags(name: options[:toolkit], add: options[:tools], remove: options[:no_tools])
       options[:toolkit_value] = toolkit if toolkit
       begin
@@ -404,7 +428,8 @@ module Samagotchi
                                                           setup: SessionSetup.new(llm_context: options[:llm_context],
                                                                                   thinking: options[:thinking],
                                                                                   toolkit: options[:toolkit_value],
-                                                                                  bundle_settings: options[:bundle_settings] || {}),
+                                                                                  bundle_settings: options[:bundle_settings] || {},
+                                                                                  parent_answers: options[:parent_answers]),
                                                           state_dir: @state_dir)
                   end
       rescue SessionContinue::Refused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
@@ -415,6 +440,9 @@ module Samagotchi
         return 1
       end
       error_line("chi send: warning: #{session.model_warning}") if session.model_warning
+      if (capped = Guardrails::ParentPolicy.capped_note(options[:parent_answers]))
+        error_line("chi send: warning: --parent-answers #{capped}")
+      end
       if through_worker
         return 1 unless deliver_new(session, prompt)
       else
@@ -473,10 +501,12 @@ module Samagotchi
         # The turn waits on a question: the message would only queue
         # behind it, and the answer goes in with chi answer.
         if (waiting = session.waiting_question(live: owner.worker?))
-          # The whole question (its options, its tags) for what a parent may give.
-          question = ParentReport.question(session.pending_question)
+          # The whole question (its options, its tags) for what a parent may
+          # give: config.yml tightened by the session's own parent_answers.
+          strategy = Guardrails::ParentPolicy.for_session(session)
+          question = ParentReport.question(session.pending_question, strategy: strategy)
           if ParentReport.approval?(waiting)
-            error_line("#{id[0, 8]}  waiting for an approval: #{ParentReport.approval_advice(question)} " \
+            error_line("#{id[0, 8]}  waiting for an approval: #{ParentReport.approval_advice(question, strategy: strategy)} " \
                        "(#{ParentReport.answer_with(id, question)})")
           else
             error_line("#{id[0, 8]}  waiting for an answer: #{ParentReport.answer_with(id, question)} (or --text); " \
@@ -603,6 +633,41 @@ module Samagotchi
     # yes (the worker holds that to its guardrails.parent_answers).
     def client_id_for(prompt) = parent_continue?(prompt) ? ClientId::CLI_ANSWER : CLIENT_ID
 
+    # The first refusal of a parent's /continue yes among the targets, each
+    # by config.yml tightened by its own parent_answers; nil when none
+    # refuses.
+    def continue_refusal_for(options)
+      target_parent_answers(options).each do |value|
+        strategy = Guardrails::ParentPolicy.effective(value)
+        refusal = Guardrails::ParentPolicy.continue_refusal(strategy: strategy)
+        return refusal if refusal
+      end
+      nil
+    end
+
+    # The targets' own parent_answers values: a --new session's
+    # --parent-answers, a --continues link's previous session's (the link
+    # keeps it), each id's. An id that doesn't resolve is skipped (#resolve
+    # reports it later); none left is config.yml's alone ([nil]).
+    def target_parent_answers(options)
+      return [options[:parent_answers]] if options[:new] && !options[:continues]
+
+      sessions = if options[:new]
+                   [target_session { SessionChain.resolve(options[:continues], state_dir: @state_dir) }]
+                 else
+                   options[:ids].map { |given| target_session { Session.resolve_id(given, state_dir: @state_dir) } }
+                 end
+      values = sessions.compact.map(&:parent_answers)
+      values.empty? ? [nil] : values
+    end
+
+    # The session the block's id names, or nil when there is none.
+    def target_session
+      Session.load(yield, state_dir: @state_dir)
+    rescue ArgumentError
+      nil
+    end
+
     # A /continue yes (or bare /continue) from a parent agent's process.
     def parent_continue?(prompt) = TurnFlow.continue_yes?(prompt) && Guardrails::ParentApprovals.parent_process?
 

data/lib/samagotchi/session.rb

@@ -220,6 +220,27 @@ module Samagotchi
       @bundle_settings = BundleSessionSettings.normalize(value)
     end
 
+    # The session's own guardrails.parent_answers (hard|standard|soft), nil
+    # for none (config.yml's). It may only tighten config.yml's
+    # (Guardrails::ParentPolicy.effective); only the user loosens it
+    # (/parent-answers in a UI). Given at creation (chi --parent-answers,
+    # chi send --new --parent-answers); a respawn, a continue and a fork keep
+    # it (SessionSetup.of), a delegate child takes its parent's.
+    attr_reader :parent_answers
+
+    # @param value [String, Symbol, nil] stripped and downcased; "" and
+    #   "default" are none; a value that isn't a level is kept as written
+    #   (read as hard: ParentPolicy.session_level)
+    def parent_answers=(value)
+      word = value.to_s.strip
+      word = word.downcase if PARENT_ANSWERS_WORDS.include?(word.downcase)
+      @parent_answers = word.empty? || word == "default" ? nil : word
+    end
+
+    # The levels and "default" (Guardrails::ParentPolicy::ORDER and UNSET;
+    # not required here: that file loads the guardrails).
+    PARENT_ANSWERS_WORDS = %w[hard standard soft default].freeze
+
     # The hook that stopped the last turn (stop_turn, or a cut with no retry
     # left), e.g. "loop-guard"; nil when it ended otherwise.
     def stopped_by
@@ -254,7 +275,7 @@ module Samagotchi
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
                    continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [],
-                   toolkit: nil, bundle_settings: {}, interrupted_turn: nil)
+                   toolkit: nil, bundle_settings: {}, interrupted_turn: nil, parent_answers: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -285,6 +306,7 @@ module Samagotchi
       self.appended_prompt_files = appended_prompt_files
       self.toolkit = toolkit
       self.bundle_settings = bundle_settings
+      self.parent_answers = parent_answers
       self.interrupted_turn = interrupted_turn
       @turn_checkpoint = nil
       @archived = false
@@ -383,6 +405,7 @@ module Samagotchi
         appended_prompt_files: setup.appended_prompt_files,
         toolkit: setup.toolkit,
         bundle_settings: setup.bundle_settings,
+        parent_answers: setup.parent_answers,
         continues: continues
       )
     end
@@ -449,7 +472,8 @@ module Samagotchi
       "appended_prompt_files" => [],
       "toolkit" => nil,
       "bundle_settings" => {},
-      "interrupted_turn" => nil
+      "interrupted_turn" => nil,
+      "parent_answers" => nil
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the

data/lib/samagotchi/session_commands.rb

@@ -13,6 +13,7 @@ require_relative "commands/registry"
 require_relative "llm_context_command"
 require_relative "thinking_command"
 require_relative "toolkit_command"
+require_relative "parent_answers_command"
 require_relative "reasoning_history_command"
 require_relative "guardrails/parent_policy"
 
@@ -35,6 +36,7 @@ module Samagotchi
     LLM_CONTEXT_COMMAND = LLMContextCommand::NAME
     THINKING_COMMAND = ThinkingCommand::NAME
     TOOLKIT_COMMAND = ToolkitCommand::NAME
+    PARENT_ANSWERS_COMMAND = ParentAnswersCommand::NAME
     REASONING_HISTORY_COMMAND = ReasoningHistoryCommand::NAME
     # A remote catalog has hundreds of ids (OpenRouter ~380): plain /models
     # shows this many per host; /models <text> lists every match.
@@ -77,12 +79,8 @@ module Samagotchi
                         id: :rollback) { |_text| rollback }
       registry.register("!", "run a shell command; its output goes into the conversation",
                         id: :shell, mid_turn: :queue, match: ->(text) { text.match?(/\A!\s*\S/) }) { |text| shell(text) }
-      registry.register(CONTINUE_COMMAND, "answer the continue offer (yes, no or no, <reason>)") do |text|
-        next reply("nothing to continue") unless @turn_flow.awaiting_continue?
-
-        answer = text.delete_prefix(CONTINUE_COMMAND).strip
-        continue_answer(answer.empty? ? CONTINUE_COMMAND : answer, as_parent: @as_parent)
-      end
+      # #run passes who sent it (as_parent:) per call.
+      registry.register(CONTINUE_COMMAND, "answer the continue offer (yes, no or no, <reason>)") { |text| continue_command(text) }
       # It reads the hosts only (the registry is mutex-guarded): mid-turn too.
       registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)", anytime: true) do |text|
         reply(models_listing(text.delete_prefix(MODELS_COMMAND).strip))
@@ -109,6 +107,11 @@ module Samagotchi
       registry.register(TOOLKIT_COMMAND, "show or change the tools this session declares (NAME, add TOOL, remove TOOL)",
                         id: :toolkit, mid_turn: show_mid_turn(TOOLKIT_COMMAND),
                         match: ->(text) { text.match?(%r{\A/toolkit(?:\s+.*)?\z}) }) { |text| toolkit(text) }
+      # Tighten-only from anyone; loosening is a user's at a UI (#run's user_ui:).
+      registry.register(PARENT_ANSWERS_COMMAND, "show or set what a parent agent may answer here (hard|standard|soft|default; " \
+                                                "never looser than config.yml's)",
+                        id: :parent_answers, mid_turn: show_mid_turn(PARENT_ANSWERS_COMMAND),
+                        match: ->(text) { text.match?(%r{\A/parent-answers(?:\s+.*)?\z}) }) { |text| parent_answers(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
@@ -258,9 +261,11 @@ module Samagotchi
     # @param as_parent [Boolean] a parent agent sent it (client cli:answer):
     #   a /continue yes is held to guardrails.parent_answers, as chi
     #   answer --option Continue is (Guardrails::ParentPolicy)
+    # @param user_ui [Boolean] a user at a UI sent it (the REPL, an attached
+    #   TUI, the web; not a piped or marked one): only such a line loosens
+    #   /parent-answers
     # @return [Result, nil] nil when +line+ is not one of these commands
-    def run(line, confirm: true, as_parent: false)
-      @as_parent = as_parent
+    def run(line, confirm: true, as_parent: false, user_ui: false)
       text = line.to_s.strip
       entry = @registry.lookup(text)
       return nil unless entry&.handler
@@ -268,17 +273,30 @@ module Samagotchi
 
       # The two that may ask take the flag; the rest never ask.
       return send(entry.id, text, confirm: confirm) if CONFIRMING.include?(entry.id)
+      # Who sent it goes to its handler per call, never through an ivar:
+      # an anytime command runs on another thread against this instance.
+      return continue_command(text, as_parent: as_parent) if entry.id == :continue
+      return parent_answers(text, user_ui: user_ui) if entry.id == :parent_answers
 
       instance_exec(text, &entry.handler)
     end
 
+    # /continue [yes|no|no, <reason>]: the continue offer's answer.
+    def continue_command(text, as_parent: false)
+      return reply("nothing to continue") unless @turn_flow.awaiting_continue?
+
+      answer = text.delete_prefix(CONTINUE_COMMAND).strip
+      continue_answer(answer.empty? ? CONTINUE_COMMAND : answer, as_parent: as_parent)
+    end
+
     # Answer the pending continue offer (yes / no / no, <reason>).
     # @param as_parent [Boolean] a parent agent's answer: a yes its strategy
     #   doesn't allow is refused (the offer stays; decision :invalid)
     # @return [Result] resume: true on yes
     def continue_answer(text, as_parent: false)
       decision, reason = TurnFlow.continue_decision(text)
-      if decision == :resume && as_parent && (refusal = Guardrails::ParentPolicy.continue_refusal)
+      if decision == :resume && as_parent &&
+         (refusal = Guardrails::ParentPolicy.continue_refusal(strategy: Guardrails::ParentPolicy.for_session(@engine.session)))
         return reply(refusal, status: :error).tap { |result| result.decision = :invalid }
       end
 
@@ -496,6 +514,14 @@ module Samagotchi
       reply(e.message, status: :error)
     end
 
+    # /parent-answers (ParentAnswersCommand); :parent_answers in changed
+    # when it set the session's own level.
+    def parent_answers(text, user_ui: false)
+      output, changed, status = ParentAnswersCommand.new(engine: @engine, save: ->(session) { save_setup(session) })
+                                                    .run(text.delete_prefix(PARENT_ANSWERS_COMMAND), user_ui: user_ui)
+      reply(output, status: status, changed: changed ? [:parent_answers] : [])
+    end
+
     # A session setting changed (/llm-context, /thinking, /reasoning-history):
     # saved with its model.
     def save_setup(session)