samagotchi 0.86.0 → 0.88.0

data/lib/samagotchi/relay.rb

@@ -16,6 +16,8 @@ module Samagotchi
     # How much of the child's task the card keeps, and the question line.
     TASK_CHARS = 200
     TASK_LINE_CHARS = 80
+    # A hook's question (QuestionDesk#ask_for_hook), relayed as such (P4).
+    HOOK_KIND = "hook"
 
     module_function
 
@@ -33,6 +35,14 @@ module Samagotchi
       asked = inner ? inner[:asked].to_s : pending.question.to_s
       task = inner ? inner[:task].to_s : task_of(child)
       who = chain.reverse.join(" → ")
+      relay = { id: relay_id, child_id: child.id, child_short: short, child_question_id: pending.id.to_s,
+                task: task, chain: chain, asked: asked, more: more.to_i }
+      if pending.kind.to_s == HOOK_KIND
+        # The asking hook's own header, kept down a chain (a relay of a relay).
+        relay[:header] = inner ? inner[:header].to_s : pending.header.to_s
+        return hook_card(pending, who, more, relay)
+      end
+
       {
         question: question_text(who, task, asked),
         options: relabel(Array(pending.options), facts[:scopes], who),
@@ -43,11 +53,33 @@ module Samagotchi
         **{ 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,
-                 task: task, chain: chain, asked: asked, more: more.to_i }
+        relay: relay
       }
     end
 
+    # A hook's question (P4: one its parent can't usefully answer): its
+    # kind, hook, options and effects as the child asked them, and no
+    # approval facts (ParentApprovals.approval? stays false on it, so the
+    # policy judges it by its own tags, as on the child).
+    def hook_card(pending, who, more, relay)
+      {
+        question: question_text(who, relay[:task], relay[:asked]),
+        options: Array(pending.options).map(&:to_s),
+        header: hook_header(who, relay[:header], more),
+        multi_select: !!pending.multi_select,
+        allow_freeform: !!pending.allow_freeform,
+        **{ effects: pending.effects, user_only: pending.user_only, hook: pending.hook }.compact,
+        kind: HOOK_KIND,
+        relay: relay
+      }
+    end
+
+    # delegate ab12 asks: Cost cap (+1 more delegate waiting)
+    def hook_header(who, header, more)
+      text = "delegate #{who} asks: #{header.to_s.strip.empty? ? "a question" : header}"
+      more.to_i.positive? ? "#{text} (+#{more} more delegate#{"s" if more.to_i > 1} waiting)" : text
+    end
+
     # delegate ab12 ("fix the flaky spec in …") asks:
     #   execute: git push origin main
     #     in /path/repo (repo samagotchi, branch main)

data/lib/samagotchi/relay_desk.rb

@@ -63,6 +63,19 @@ module Samagotchi
       end
     end
 
+    # Whether the parent's user (or a parent agent) answered or dismissed a
+    # relay of this child's question: it isn't relayed again (a refused
+    # answer leaves it on the child's card). A closed one (a Stop, the
+    # child gone) is not settled. Forgotten after KEEP_SECONDS or a restart.
+    def settled?(child_id, child_question_id)
+      @mutex.synchronize do
+        prune
+        @relays.each_value.any? do |relay|
+          relay[:state] == "answered" && relay[:child_id] == child_id.to_s && relay[:child_question_id] == child_question_id.to_s
+        end
+      end
+    end
+
     # Whether a relay is open, or settled recently enough that its child
     # may still ask about it: a restart would drop them.
     def active?

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)

data/lib/samagotchi/session_setup.rb

@@ -18,24 +18,26 @@ module Samagotchi
   # +toolkit+ a Toolkit or nil (SessionManager.spawn_session gives the
   # session config's toolkit.default then), +bundle_settings+ the bundle
   # settings chi --set gave ({bundle => {key => value}}, frozen; {} with
-  # none), which Plugin::Context#settings lays over config.yml's.
+  # none), which Plugin::Context#settings lays over config.yml's,
+  # +parent_answers+ the session's own guardrails.parent_answers (a level
+  # String, tighten-only: Guardrails::ParentPolicy.effective) or nil.
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
-  # without one (but the toolkit its delegate call named); a continue and a
-  # fork copy their session's (.of).
+  # without one (but the toolkit its delegate call named, and its parent's
+  # parent_answers); a continue and a fork copy their session's (.of).
   SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit,
-                             :bundle_settings) do
+                             :bundle_settings, :parent_answers) do
     def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil,
-                   bundle_settings: {})
+                   bundle_settings: {}, parent_answers: nil)
       super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,
             appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit,
-            bundle_settings: BundleSessionSettings.normalize(bundle_settings))
+            bundle_settings: BundleSessionSettings.normalize(bundle_settings), parent_answers: parent_answers&.to_s)
     end
 
     def empty?
       llm_context.nil? && thinking.nil? && reasoning_history.nil? && appended_prompt_files.empty? && toolkit.nil? &&
-        bundle_settings.empty?
+        bundle_settings.empty? && parent_answers.nil?
     end
 
     # A session's own setup, for a session that starts from it. Its
@@ -48,7 +50,7 @@ module Samagotchi
 
       new(llm_context: session.llm_context, thinking: session.thinking, reasoning_history: session.reasoning_history,
           appended_prompt_files: session.appended_prompt_files, toolkit: Toolkit.of(session.toolkit),
-          bundle_settings: session.bundle_settings)
+          bundle_settings: session.bundle_settings, parent_answers: session.parent_answers)
     end
   end
 end

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -53,6 +53,10 @@ module Samagotchi
       #   the line an existing session's run prints (--set too)
       # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
       #   a new session's setup carries them; an existing session keeps its own
+      # @param parent_answers [String, nil] --parent-answers: a new session's
+      #   own guardrails.parent_answers; an existing session keeps its own
+      #   (never sent as a /parent-answers command: that would be a
+      #   loosening route from a command line)
       # @param state_dir [String, nil] where the sessions are (the default
       #   state dir by default): the worker's, for the attached loop too
       # @return [Symbol] :detached, :closed when the worker went away,
@@ -60,12 +64,12 @@ module Samagotchi
       #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
               memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
-              toolkit_flags: [], bundle_settings: {}, state_dir: nil)
+              toolkit_flags: [], bundle_settings: {}, parent_answers: nil, state_dir: nil)
         state_dir ||= Session.default_state_dir
         client = connect(attach: attach, shared: shared, resume: resume, model: model, state_dir: state_dir,
                          memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking,
                          appended_prompt_files: appended_prompt_files, toolkit: toolkit, toolkit_flags: toolkit_flags,
-                         bundle_settings: bundle_settings)
+                         bundle_settings: bundle_settings, parent_answers: parent_answers)
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
@@ -83,7 +87,9 @@ module Samagotchi
         ensure
           close_surface(surface)
         end
-        report_unanswered(attached.unanswered, session_id: client.session_id) if ended == :unanswered && attached.unanswered
+        if ended == :unanswered && attached.unanswered
+          report_unanswered(attached.unanswered, session_id: client.session_id, state_dir: state_dir)
+        end
         report_ended(ended)
         ended
       end
@@ -92,9 +98,12 @@ module Samagotchi
       # --wait` prints it (ParentReport), so a script or a parent agent
       # can answer it with chi answer.
       # @param pending [Hash] the pending question as the Bridge sent it
-      def report_unanswered(pending, session_id:, err: $stderr)
+      # @param state_dir [String, nil] where the session file is: what a
+      #   parent may pick follows its own parent_answers too
+      def report_unanswered(pending, session_id:, err: $stderr, state_dir: nil)
         question = PendingQuestion.from_file(pending)
-        err.print("chi: #{ParentReport.question_text(question, session_id: session_id)}")
+        strategy = ParentReport.strategy_for(session_id, state_dir: state_dir || Session.default_state_dir)
+        err.print("chi: #{ParentReport.question_text(question, session_id: session_id, strategy: strategy)}")
         err.flush
       end
 
@@ -134,7 +143,7 @@ module Samagotchi
       # @raise [Error]
       def connect(attach: nil, shared: false, resume: nil, model: nil, state_dir: nil, wait: BRIDGE_WAIT,
                   memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
-                  toolkit_flags: [], bundle_settings: {}, err: $stderr)
+                  toolkit_flags: [], bundle_settings: {}, parent_answers: nil, err: $stderr)
         sd = state_dir || Session.default_state_dir
         if attach || resume
           warn_memory_flags_ignored(attach || resume, memories, muted_memories, err, appended_prompt_files: appended_prompt_files,
@@ -156,7 +165,8 @@ module Samagotchi
                                                  setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
                                                                          thinking: Thinking.session_level(thinking),
                                                                          appended_prompt_files: appended_prompt_files,
-                                                                         toolkit: toolkit, bundle_settings: bundle_settings))
+                                                                         toolkit: toolkit, bundle_settings: bundle_settings,
+                                                                         parent_answers: parent_answers))
                   end
         client = BridgeClient.wait_for(session.id, session_dir: Session.session_dir(session.id, state_dir: sd), timeout: wait)
         client || raise(Error, "the worker for session #{session.id} did not start its Bridge in time")
@@ -185,7 +195,7 @@ module Samagotchi
 
         verb = flags.size == 1 ? "applies" : "apply"
         names = flags.size > 2 ? "#{flags[0..-2].join(", ")} and #{flags.last}" : flags.join(" and ")
-        err.puts "(#{names} #{verb} to a new session; #{session_id}'s prompt is already built)"
+        err.puts "(#{names} #{verb} to a new session; #{session_id} keeps its own)"
       end
 
       # @return [BridgeClient, nil] the running worker's, or nil when none runs

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -592,10 +592,7 @@ module Samagotchi
       # The worker runs it and every UI renders its :command_ran, this one
       # too, so nothing waits here.
       def send_command(line)
-        # A parent agent's /continue yes goes as chi answer's: the worker
-        # holds it to guardrails.parent_answers.
-        client_id = @as_parent && TurnFlow.continue_yes?(line) ? ClientId::CLI_ANSWER : @client_id
-        reply = @client.post_command(line: line, client_id: client_id)
+        reply = @client.post_command(line: line, client_id: client_id_for(line))
         if reply.status == 202
           # Input from a pipe ends once its output is in (#command_ran).
           command_id = reply.json&.fetch("command_id", nil)
@@ -808,13 +805,27 @@ module Samagotchi
         steer_cut_note(ack["cut"].to_s.to_sym, ack["cut_after"])
       end
 
+      # The client id +line+ goes with, as a command (#send_command) or as a
+      # message the Bridge may run as one (#send_prompt: /cut and /queue
+      # text). A parent agent's /continue yes and /parent-answers go as chi
+      # answer's: the worker holds the first to guardrails.parent_answers and
+      # never takes the second as a user's loosening. The command is the
+      # registry's own match (the worker's), not a pattern of ours.
+      def client_id_for(line)
+        return @client_id unless @as_parent
+        return ClientId::CLI_ANSWER if TurnFlow.continue_yes?(line)
+        return ClientId::CLI_ANSWER if command_registry.lookup(line)&.id == :parent_answers
+
+        @client_id
+      end
+
       def send_prompt(text, delivery: nil)
         persist_recent_history(text)
         images = attach_images(text)
         return own_prompt_failed if images.nil?
 
         running = @running
-        options = { prompt: text, client_id: @client_id }
+        options = { prompt: text, client_id: client_id_for(text) }
         options[:no_interrupt] = true if @no_interrupt
         options[:images] = images unless images.empty?
         options[:delivery] = delivery if delivery

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -96,7 +96,8 @@ module Samagotchi
         case reason.to_s
         when "answered_on_child" then "(answered in #{@delegate})"
         when "child_gone" then "(#{@delegate}'s worker is gone)"
-        when "dismissed" then "(denied)"
+        # A relayed hook question's dismissal: the hook decides what it means.
+        when "dismissed" then approval? ? "(denied)" : "(dismissed)"
         else "(left open in #{@delegate})"
         end
       end

data/lib/samagotchi/terminal_ui.rb

@@ -105,10 +105,14 @@ module Samagotchi
     # @param bundle_settings [Hash] --set's values (BundleSessionSettings):
     #   a new session's own; a resumed one keeps its own (--set is in
     #   +toolkit_flags+ then)
+    # @param parent_answers [String, nil] --parent-answers: a new session's
+    #   own guardrails.parent_answers; a resumed one keeps its own (named in
+    #   +toolkit_flags+ then)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
                    spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
-                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], bundle_settings: {})
+                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], bundle_settings: {}, parent_answers: nil)
       @scratch        = scratch
+      @parent_answers = parent_answers
       @toolkit        = toolkit
       @toolkit_flags  = toolkit_flags
       @bundle_settings = bundle_settings
@@ -281,7 +285,7 @@ module Samagotchi
         muted_memory_names: @muted_memory_names,
         scratch: @scratch,
         setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured,
-                                bundle_settings: @bundle_settings)
+                                bundle_settings: @bundle_settings, parent_answers: @parent_answers)
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.
@@ -733,7 +737,7 @@ module Samagotchi
       return if @toolkit_flags.empty?
 
       names = @toolkit_flags.size > 1 ? "#{@toolkit_flags[0..-2].join(", ")} and #{@toolkit_flags.last}" : @toolkit_flags.first
-      warn "(#{names} #{@toolkit_flags.size == 1 ? "applies" : "apply"} to a new session; #{session.id}'s prompt is already built)"
+      warn "(#{names} #{@toolkit_flags.size == 1 ? "applies" : "apply"} to a new session; #{session.id} keeps its own)"
     end
     private :warn_toolkit_flags_ignored
 
@@ -876,9 +880,11 @@ module Samagotchi
         command = if command_registry.anytime?(input)
                     @engine.running_anytime { @commands.run(input, confirm: confirm) }
                   else
-                    # A parent's /continue yes is held to guardrails.parent_answers.
-                    parent = TurnFlow.continue_yes?(input) && as_parent? ? { as_parent: true } : {}
-                    @commands.run(input, confirm: confirm, **parent)
+                    # A parent's /continue yes is held to guardrails.parent_answers;
+                    # only a person here (not piped, no agent marker) loosens
+                    # /parent-answers.
+                    parent = as_parent?
+                    @commands.run(input, confirm: confirm, as_parent: parent && TurnFlow.continue_yes?(input), user_ui: !parent)
                   end
         if command
           show_command_result(command)