samagotchi 0.86.0 → 0.87.0

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")

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.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.
@@ -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)

data/lib/samagotchi/tools/delegate.rb

@@ -134,7 +134,10 @@ module Samagotchi
                  "(the most is #{max}, #{MAX_CHILDREN_KEY}): #{ids}. #{full_hint(peers)}"
         end
 
-        setup = toolkit.empty? ? SessionSetup.new : SessionSetup.new(toolkit: Toolkit.new(name: toolkit))
+        # The parent's own parent_answers, as it is now (a snapshot): the
+        # child's answers are held at least as tight.
+        setup = SessionSetup.new(toolkit: toolkit.empty? ? nil : Toolkit.new(name: toolkit),
+                                 parent_answers: parent.parent_answers)
         child = SessionManager.spawn_session(prompt: task, working_directory: folder,
                                              model_name: child_model(model, parent), memories: CHILD_MEMORIES,
                                              parent_id: parent.id, delegate: true, setup: setup, state_dir: state_dir)

data/lib/samagotchi/tools/delegate_wait.rb

@@ -213,6 +213,10 @@ module Samagotchi
       # @return [String]
       def finish(wait, child_id, timeout:, report: false, reports: "off")
         status = ParentReport.status(wait)
+        # What the parent may pick on the child's question: config.yml
+        # tightened by the child session's own parent_answers (the session
+        # the wait read; none: config.yml's).
+        strategy = Guardrails::ParentPolicy.for_session(wait.session)
         case wait.status
         when :done
           reply_result(child_id, status, wait.text)
@@ -221,11 +225,11 @@ module Samagotchi
         when :stopped
           result(child_id, status, "the child was stopped (chi sessions stop); delegate with session: #{child_id} starts it again with a message")
         when :waiting_for_answer
-          result(child_id, status, waiting_text(child_id, wait.question, report: report, reports: reports))
+          result(child_id, status, waiting_text(child_id, wait.question, report: report, reports: reports, strategy: strategy))
         when :canceled
           canceled_result(child_id, reports: reports)
         when :no_reply
-          result(child_id, status, "#{no_reply_text(wait, child_id)}; its session shows what happened")
+          result(child_id, status, "#{no_reply_text(wait, child_id, strategy: strategy)}; its session shows what happened")
         when :worker_gone
           result(child_id, status,
                  "the child's worker is gone (it stopped or crashed); delegate with session: #{child_id} starts it again with a message")
@@ -266,8 +270,8 @@ module Samagotchi
       end
 
       # ParentReport's line for a turn that left no reply, about the child.
-      def no_reply_text(wait, child_id)
-        ParentReport.no_reply_line(wait, child_id).sub(/\Athe turn/, "the child's turn")
+      def no_reply_text(wait, child_id, strategy: nil)
+        ParentReport.no_reply_line(wait, child_id, strategy: strategy).sub(/\Athe turn/, "the child's turn")
       end
 
       def result(child_id, status, text)
@@ -303,9 +307,9 @@ module Samagotchi
       # A report's last line differs (+report+): "waits again" made models
       # call delegate_result right after answering Continue.
       # The tool's last line follows #reports_mode.
-      def waiting_text(child_id, pending, report: false, reports: "off")
-        text = "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id)}"
-        if ParentReport.continue?(pending) && ParentReport.may_continue?(pending)
+      def waiting_text(child_id, pending, report: false, reports: "off", strategy: nil)
+        text = "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id, strategy: strategy)}"
+        if ParentReport.continue?(pending) && ParentReport.may_continue?(pending, strategy: strategy)
           text += "The child ran out of steps before it answered. Decide: continue it (run the chi answer command " \
                   "above with execute) if it is getting somewhere; send it a narrower follow-up with delegate " \
                   "session: #{child_id} (that drops the question); or stop it and report back to your user.\n"

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.86.0"
+  VERSION = "0.87.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/worker.rb

@@ -794,7 +794,9 @@ module Samagotchi
     #   as its output
     def run_command_line(command)
       @engine.holding_announcements do
-        command_result(command) { @commands.run(command.line, confirm: confirm?(command), as_parent: as_parent?(command)) }
+        command_result(command) do
+          @commands.run(command.line, confirm: confirm?(command), as_parent: as_parent?(command), user_ui: user_ui?(command))
+        end
       end
     end
 
@@ -808,6 +810,12 @@ module Samagotchi
     # guardrails.parent_answers (SessionCommands#continue_answer).
     def as_parent?(command) = command.client_id.to_s == ClientId::CLI_ANSWER
 
+    # Whether +command+ is a user's at a UI (a web tab, a chi TUI, a card's
+    # click), not a parent agent's: only such a line loosens
+    # /parent-answers. chi send, a delegate's follow-up, a plugin and an
+    # input with no client never do (ParentAnswersCommand).
+    def user_ui?(command) = ClientId.interactive?(command.client_id) && !as_parent?(command)
+
     # The block's Result for +command+; one that raised, or found no
     # command for the line, is an error Result saying so.
     # @return [SessionCommands::Result]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.86.0
+  version: 0.87.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -422,6 +422,7 @@ files:
 - lib/samagotchi/note_delivery.rb
 - lib/samagotchi/output_formatter.rb
 - lib/samagotchi/owner_lock.rb
+- lib/samagotchi/parent_answers_command.rb
 - lib/samagotchi/parent_report.rb
 - lib/samagotchi/paths.rb
 - lib/samagotchi/peer_sources.rb