samagotchi 0.85.0 → 0.87.0

data/lib/samagotchi/question_desk.rb

@@ -10,8 +10,7 @@ require_relative "log"
 require_relative "pending_question"
 require_relative "question_answer"
 require_relative "tools/ask_user_question"
-require_relative "guardrails/parent_approvals"
-require_relative "guardrails/parent_continue"
+require_relative "guardrails/parent_policy"
 
 module Samagotchi
   # An Engine's question flow: the one open question (ask_user_question, a
@@ -36,18 +35,25 @@ module Samagotchi
     class NotPending < ArgumentError; end
 
     # Raised by #answer when a parent agent's answer (chi answer's client
-    # id) allows an approval further than this worker's
-    # guardrails.parent_approvals lets it (Guardrails::ParentApprovals), or
-    # continues a turn turn.parent_continue keeps it from
-    # (Guardrails::ParentContinue). The question stays open; transports map
+    # id) picks an option this worker's strategy keeps parents from
+    # (Guardrails::ParentPolicy). The question stays open; transports map
     # it to 403.
     class Refused < StandardError
-      # @return [Symbol] :off, :once_only, :protected or :stop_only
+      # @return [Symbol] ParentPolicy.refusal's: :user_only, :permit_wide,
+      #   :permit or :spend
       attr_reader :reason
 
-      def initialize(reason)
+      def initialize(reason, pending:, strategy:)
         @reason = reason
-        super(reason == :stop_only ? "a parent may not continue this turn" : "a parent may not allow this approval (#{reason})")
+        @pending = pending
+        @strategy = strategy
+        super("a parent may not pick that option here (#{reason})")
+      end
+
+      # The line for the parent (ParentPolicy.message).
+      # @param typed [Boolean] typed at a ? prompt (the REPL)
+      def detail(typed: false)
+        Guardrails::ParentPolicy.message(reason, pending: @pending, strategy: @strategy, typed: typed)
       end
     end
 
@@ -290,7 +296,7 @@ module Samagotchi
     # @param freeform [String, nil]
     # @param client_id [String, nil] who answers
     # @param parent_agent [Boolean, nil] the answer is a parent agent's, so
-    #   it is held to guardrails.parent_approvals on an approval and doesn't
+    #   it is held to Guardrails::ParentPolicy and doesn't
     #   bring the session back to the lists; nil: chi answer's client id says so
     # @return [QuestionAnswer] the answer; a parent agent's carries by: "parent_agent"
     # @raise [NotPending, ArgumentError, Refused]
@@ -299,9 +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.
-      parent_setting = Guardrails::ParentApprovals.setting if parent_agent
-      parent_continue = Guardrails::ParentContinue.allowed? 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
@@ -313,10 +319,7 @@ module Samagotchi
         raise NotPending, "question already answered" if @answer
         raise NotPending, "question #{pending.status}" unless pending.status.to_s == "pending"
 
-        answer = validated_answer(pending, sel, fm, parent_agent: parent_agent, parent_setting: parent_setting)
-        if parent_agent && (reason = Guardrails::ParentContinue.refusal(pending, sel, allowed: parent_continue))
-          raise Refused, reason
-        end
+        answer = validated_answer(pending, sel, fm, parent_agent: parent_agent, strategy: strategy)
 
         if @standing
           # No waiter: cleared here, so a second answer finds none.
@@ -401,9 +404,13 @@ module Samagotchi
     # web), single-select, kind "hook". A --non-interactive run has no one
     # to ask: nil at once. Anything but an answer (a sync handler's text, no
     # answer, cancelled) is nil too.
+    # @param effects [Hash, nil] label => effect for a parent agent's answer
+    #   (Guardrails::ParentPolicy); a label left out is "answer". A label
+    #   the options don't have, or an effect it doesn't know, makes the ask
+    #   invalid (nil, warned), like bad options.
     # @return [Hash, nil] {selected:, freeform:, selected_indices:} (a plain
     #   Hash: the bundle boundary)
-    def ask_for_hook(question, options, header, allow_freeform, hook)
+    def ask_for_hook(question, options, header, allow_freeform, hook, effects: nil)
       return nil if @interface_lookup.call == :non_interactive
 
       opts = Tools::AskUserQuestion.normalize_options(options)
@@ -411,9 +418,16 @@ module Samagotchi
         Log.warn(:hooks, "ask_user_invalid", echo: "[samagotchi:hooks] #{hook} asked with invalid options (2-8 strings)", hook: hook.to_s)
         return nil
       end
+      tags = Guardrails::ParentPolicy.option_tags(opts, effects)
+      if tags == false
+        Log.warn(:hooks, "ask_user_invalid",
+                 echo: "[samagotchi:hooks] #{hook} asked with invalid effects (option label => " \
+                       "#{Guardrails::ParentPolicy::EFFECTS.join("|")})", hook: hook.to_s)
+        return nil
+      end
 
       fields = { question: question.to_s, options: opts, header: header, multi_select: false,
-                 allow_freeform: !!allow_freeform, kind: "hook", hook: hook.to_s }.compact
+                 allow_freeform: !!allow_freeform, effects: tags, kind: "hook", hook: hook.to_s }.compact
       answer = open_question(fields)
       return nil unless answer.is_a?(QuestionAnswer)
 
@@ -493,11 +507,11 @@ module Samagotchi
 
     # An answer to +pending+, checked: the selections are its options (value
     # == label in v1), one for a single-select, one or a text when required,
-    # and a parent agent's within guardrails.parent_approvals. Under the
+    # and a parent agent's within its strategy (ParentPolicy). Under the
     # question lock: checked against the question pending now.
     # @return [QuestionAnswer]
     # @raise [ArgumentError, Refused]
-    def validated_answer(pending, sel, fm, parent_agent:, parent_setting:)
+    def validated_answer(pending, sel, fm, parent_agent:, strategy:)
       opts = Array(pending.options)
       invalid = sel.reject { |v| opts.include?(v) }
       raise ArgumentError, "invalid selection: #{invalid.join(", ")} (valid: #{opts.join(", ")})" unless invalid.empty?
@@ -505,10 +519,10 @@ module Samagotchi
       raise ArgumentError, "selection required" if pending.multi_select == false && sel.empty? && fm.nil?
 
       indices = sel.map { |v| opts.index(v) }
-      # The one whose answer settles the approval (Approval.settle, by index).
-      if parent_setting
-        reason = Guardrails::ParentApprovals.refusal(pending, indices, setting: parent_setting)
-        raise Refused, reason if reason
+      # By index, as the effects (and Approval.settle) read it.
+      if strategy
+        reason = Guardrails::ParentPolicy.refusal(pending, indices, strategy: strategy)
+        raise Refused.new(reason, pending: pending, strategy: strategy) if reason
       end
       QuestionAnswer.new(id: pending.id.to_s, selected: sel, freeform: fm, selected_indices: indices.compact,
                          by: parent_agent ? "parent_agent" : nil)

data/lib/samagotchi/queued_command.rb

@@ -9,10 +9,11 @@ module Samagotchi
   # question's answer), whose line the UIs leave out. The worker adds
   # where it waits (Worker#on_command): +mid_turn+ (the policy it got:
   # :queue, :refuse, :loop), +after_seq+ (the event count then, so a
-  # turn's end knows it came before) and +after_file+ (the input file it
-  # runs after, a basename).
-  QueuedCommand = Data.define(:command_id, :client_id, :line, :card, :mid_turn, :after_seq, :after_file) do
-    def initialize(command_id:, line:, client_id: nil, card: false, mid_turn: nil, after_seq: nil, after_file: nil) = super
+  # turn's end knows it came before), +after_file+ (the input file it runs
+  # after, a basename) and +enqueued_id+ (a file-delivered command's sender).
+  QueuedCommand = Data.define(:command_id, :client_id, :line, :card, :mid_turn, :after_seq, :after_file, :enqueued_id) do
+    def initialize(command_id:, line:, client_id: nil, card: false, mid_turn: nil, after_seq: nil, after_file: nil,
+                   enqueued_id: nil) = super
 
     # A new command with a fresh id.
     def self.mint(line, client_id: nil, card: false)

data/lib/samagotchi/relay.rb

@@ -6,7 +6,9 @@ module Samagotchi
   # A delegate's approval reopened as the parent session's own (the
   # approval relay): the same kind "approval" and the same approval facts,
   # so every UI shows it as it shows the parent's own approvals, the diff
-  # included, and Guardrails::ParentApprovals judges it the same way. The
+  # included, and Guardrails::ParentPolicy judges it the same way: the
+  # child's effects and user_only come along (an older child's question
+  # has none; the policy derives them from the approval facts). The
   # question text names the delegate and its task over the child's own
   # text; `relay:` says which child and which of its questions it answers.
   # A relay of a relay (a grandchild's) grows relay.chain.
@@ -37,6 +39,8 @@ module Samagotchi
         header: header(who, more),
         multi_select: false,
         allow_freeform: pending.allow_freeform.nil? || !!pending.allow_freeform,
+        # Same order: only the session option's label changes.
+        **{ effects: pending.effects, user_only: pending.user_only }.compact,
         kind: Guardrails::Approval::KIND,
         approval: facts,
         relay: { id: relay_id, child_id: child.id, child_short: short, child_question_id: pending.id.to_s,

data/lib/samagotchi/relay_verifier.rb

@@ -5,7 +5,6 @@ require_relative "session"
 require_relative "bridge_client"
 require_relative "worker_sidecar"
 require_relative "question_desk"
-require_relative "guardrails/parent_approvals"
 require_relative "log"
 
 module Samagotchi
@@ -24,8 +23,8 @@ module Samagotchi
     end
 
     # @return [Array(Hash, Integer, Hash)] headers, status, body: 200
-    #   answered, 409 no longer pending, 403 refused (a parent agent's allow
-    #   beyond this worker's guardrails.parent_approvals), 422
+    #   answered, 409 no longer pending, 403 refused (a parent agent's pick
+    #   beyond this worker's Guardrails::ParentPolicy), 422
     #   relay_unverified (logged; the question stays open)
     def answer(relay_id:, question_id:)
       parent_id = own_parent_id or return unverified("this session has no parent", relay_id)
@@ -59,8 +58,8 @@ module Samagotchi
       not_pending(question_id)
     rescue QuestionDesk::Refused => e
       log("relay_refused", relay_id, id: question_id, reason: e.reason)
-      [{}, 403, { error: "parent_approval_refused", reason: e.reason.to_s,
-                  detail: Guardrails::ParentApprovals.message(e.reason) }]
+      [{}, 403, { error: "parent_answer_refused", reason: e.reason.to_s,
+                  detail: e.detail }]
     rescue ArgumentError => e
       unverified("the answer doesn't fit the question: #{e.message}", relay_id)
     end

data/lib/samagotchi/reply_wait.rb

@@ -3,6 +3,7 @@
 require_relative "session"
 require_relative "turn_note"
 require_relative "session_inbox"
+require_relative "turn_checkpoint"
 require_relative "worker_sidecar"
 
 module Samagotchi
@@ -32,9 +33,10 @@ module Samagotchi
     # @!attribute question [PendingQuestion, nil] the pending question
     #   (:waiting_for_answer)
     # @!attribute outcome [String, nil] how the turn ended when it left no
-    #   reply (:no_reply): "failed", "canceled", "completed" (empty),
+    #   reply (:no_reply): "failed", "canceled", "completed" (empty turn or
+    #   file-delivered command ran without a turn),
     #   "exhausted" (it ran out of iterations, with nobody asked whether to
-    #   continue) or "not_continued" (a Stop answered the step-limit
+    #   continue), "not_continued" (a Stop answered the step-limit
     #   question; no turn ran), from the session's last_turn, or "removed"
     #   (turn:'s queued input was taken back before it ran, its tombstone:
     #   SessionInbox.removed?; no turn ran); nil when unknown. With
@@ -47,8 +49,9 @@ module Samagotchi
     #   retry
     # @!attribute cancel_reason [String, nil] a "canceled" turn's reason
     #   (user, hook, ctrl_c, manual, session_stopped: the session was
-    #   stopped mid-turn), passed through as the worker saved it; any
-    #   reason is a "canceled" outcome
+    #   stopped mid-turn; worker_stopped: turn:'s worker died in it and the
+    #   next one settled it, TurnCheckpoint.settled_turn), passed through
+    #   as the worker saved it; any reason is a "canceled" outcome
     # @!attribute stopped_by [String, nil] the hook that canceled it
     #   (loop-guard)
     # @!attribute session [Session, nil] the session as the look that
@@ -156,6 +159,12 @@ module Samagotchi
           reply.session = settled(session, id, state_dir: state_dir)
           return reply
         end
+        # Its worker died in it and the next one settled it, or an input
+        # command finished without a turn. After the reply check: a worker
+        # killed between writing the reply and its idle save left the reply.
+        if turn && (settled = TurnCheckpoint.settled_turn(session_dir, turn))
+          return Result.new(status: :no_reply, outcome: settled.outcome, session: session, **settled.stop_facts)
+        end
 
         case session.status
         when Session::STATUS_ERROR
@@ -314,7 +323,7 @@ module Samagotchi
 
       running = session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == id
       queued = SessionInbox.waiting_input(session_dir, id) == :turn_end
-      ended = session.last_turn&.enqueued_id == id
+      ended = session.last_turn&.enqueued_id == id || !TurnCheckpoint.settled_turn(session_dir, id).nil?
       running || queued || ended
     end
 

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"
@@ -12,6 +13,9 @@ require_relative "session_chain"
 require_relative "context_quote"
 require_relative "reply_wait"
 require_relative "parent_report"
+require_relative "turn_flow"
+require_relative "guardrails/parent_approvals"
+require_relative "guardrails/parent_policy"
 require_relative "image_store"
 require_relative "host_registry"
 require_relative "model_profile"
@@ -40,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
@@ -92,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
@@ -150,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"
@@ -241,6 +251,23 @@ module Samagotchi
       if prompt && (local = local_command(prompt))
         return refuse_local_command(local, options)
       end
+
+      # A parent agent's /continue yes is chi answer --option Continue by
+      # 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])
@@ -294,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
@@ -313,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
@@ -336,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
@@ -393,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
@@ -404,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
@@ -414,7 +453,8 @@ module Samagotchi
       return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
-                                 timeout: options[:timeout], report_turn_id: @sent_enqueued_id)
+                                 timeout: options[:timeout], turn: @sent_input_file ? @sent_enqueued_id : nil,
+                                 report_turn_id: @sent_enqueued_id)
     end
 
     # The model the new session will run, for the images check: --model
@@ -461,11 +501,15 @@ 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: 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::DENY_AND_TELL} " \
-                       "(#{ParentReport.answer_with(id, waiting)})")
+            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, waiting)} (or --text); " \
+            error_line("#{id[0, 8]}  waiting for an answer: #{ParentReport.answer_with(id, question)} (or --text); " \
                        "chi --attach #{id} shows it")
           end
         else
@@ -485,7 +529,9 @@ module Samagotchi
       # The ack's id names the queued message's turn, also when the turn
       # running at the check ended before it went in (an idle worker's ack
       # says next_step, and the file still runs as that turn).
-      turn = @queue ? @sent_enqueued_id : nil
+      # A file fallback has no delivery field; use its id to see terminal
+      # outcomes for commands that finish without starting a turn.
+      turn = @sent_enqueued_id if @queue || @sent_input_file
       report_turn_id = if @queue
                          turn
                        elsif session.status == Session::STATUS_RUNNING
@@ -493,7 +539,8 @@ module Samagotchi
                        else
                          @sent_enqueued_id
                        end
-      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn, queued: !turn.nil?,
+      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn,
+                          queued: @queue && !turn.nil?,
                           report_turn_id: report_turn_id)
     end
 
@@ -550,7 +597,7 @@ module Samagotchi
       begin
         refs = copy_images(dir)
         if BridgeClient.wait_for(session.id, session_dir: dir, timeout: SessionManager::TURN_BRIDGE_WAIT)
-          result = SessionManager.deliver_turn(session.id, prompt: prompt, client_id: CLIENT_ID, images: refs,
+          result = SessionManager.deliver_turn(session.id, prompt: prompt, client_id: client_id_for(prompt), images: refs,
                                                            state_dir: @state_dir)
         end
       rescue StandardError => e
@@ -569,6 +616,7 @@ module Samagotchi
       end
 
       ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      @sent_input_file = !ack.key?("delivery")
       @sent_enqueued_id = (ack["enqueued_id"] || ack[:enqueued_id])&.to_s
       @sent_command = command_ack?(result[:ack])
       @info.puts("#{session.id}  started#{continued_words(session)}#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
@@ -581,6 +629,48 @@ module Samagotchi
     # /turn whose line is one answers with its command_id).
     def command_ack?(ack) = ack.is_a?(Hash) && !ack["command_id"].to_s.empty?
 
+    # chi send's client id, or chi answer's for a parent agent's /continue
+    # 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?
+
     # Whether +text+ may be a session command, which only its worker knows
     # (a bundle's too).
     def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
@@ -648,7 +738,7 @@ module Samagotchi
       delivery = if @queue then Delivery::QUEUE
                  elsif @cut && running then Delivery::CUT
                  end
-      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, images: refs, state_dir: @state_dir,
+      result = SessionManager.deliver_turn(id, prompt: prompt, client_id: client_id_for(prompt), images: refs, state_dir: @state_dir,
                                                delivery: delivery)
       unless result[:status] == :accepted
         # A worker older than queueing would steer it: refused, not sent.
@@ -664,6 +754,7 @@ module Samagotchi
       end
 
       ack = result[:ack].is_a?(Hash) ? result[:ack] : {}
+      @sent_input_file = !ack.key?("delivery")
       # What the worker applied, for --format json: its ack's delivery
       # (next_step for an idle session) and a cut's outcome.
       @sent_delivery = ack["delivery"] || delivery

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