samagotchi 0.86.0 → 0.88.0

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_relay.rb

@@ -4,6 +4,7 @@ require_relative "../session"
 require_relative "../bridge_client"
 require_relative "../relay"
 require_relative "../guardrails/approval"
+require_relative "../guardrails/parent_policy"
 require_relative "../log"
 require_relative "../question_answer"
 
@@ -35,10 +36,39 @@ module Samagotchi
 
       module_function
 
+      # Kinds a relay may carry.
+      HOOK_KIND = "hook"
+
       # @param relay [#open_question, #relay_desk] Peers#relay
+      # @param strategy [Guardrails::ParentPolicy::Strategy] the child's
+      #   (ParentPolicy.for_session(child))
       # @return [Boolean] a relay can take this question
-      def relayable?(relay, question)
-        !relay.nil? && question.is_a?(PendingQuestion) && question.kind.to_s == Guardrails::Approval::KIND
+      # @param child_id [String, nil] the asking child: a hook's question
+      #   already answered on one of this parent's relays
+      #   (RelayDesk#settled?) isn't relayed again; an approval is (as before
+      #   P4: a refused or undelivered answer is offered again)
+      def relayable?(relay, question, strategy:, child_id: nil)
+        return false if relay.nil? || !relay?(question, strategy: strategy)
+        return true unless child_id && question.kind.to_s == HOOK_KIND
+
+        !relay.relay_desk.settled?(child_id, question.id)
+      end
+
+      # Whether a delegate's question goes to the parent's user rather than
+      # its model: every approval, and a hook's question the parent can't
+      # usefully answer under the child's strategy
+      # (Guardrails::ParentPolicy.parent_decides?). The one place that says
+      # which kinds the relay carries: the wait (DelegateWait.call), the
+      # look at the other children (Others#waiting) and the delegate
+      # reports (ChildReports) all ask it.
+      def relay?(question, strategy:)
+        return false unless question.is_a?(PendingQuestion)
+
+        case question.kind.to_s
+        when Guardrails::Approval::KIND then true
+        when HOOK_KIND then !Guardrails::ParentPolicy.parent_decides?(question, strategy: strategy)
+        else false
+        end
       end
 
       # Relay the child's pending approval and wait until it settles.
@@ -79,10 +109,11 @@ module Samagotchi
 
       # Record the parent's answer, tell the child, and say what came of it.
       def settle(answer, fields, client:, desk:, relay_id:, qid:)
-        what = what_text(fields[:approval])
+        what = fields[:kind] == HOOK_KIND ? hook_what(fields) : what_text(fields[:approval])
+        hook = fields[:kind] == HOOK_KIND
         if answer.is_a?(Hash) && answer[:error] == "cancelled"
           desk.close(relay_id)
-          return closed(answer[:reason].to_s, what, client: client, relay_id: relay_id, qid: qid)
+          return closed(answer[:reason].to_s, what, client: client, relay_id: relay_id, qid: qid, hook: hook)
         end
 
         dismissed = !answer.is_a?(QuestionAnswer)
@@ -90,17 +121,18 @@ module Samagotchi
         desk.record(relay_id, selected_indices: dismissed ? [] : answer.selected_indices,
                               freeform: dismissed ? nil : answer.freeform, dismissed: dismissed, by: by)
         response = post(client, "answered", relay_id, qid)
-        Outcome.new(line: line(what, delivered(response, answer, fields, dismissed)), stopped: false)
+        Outcome.new(line: line(what, delivered(response, answer, fields, dismissed), hook: hook), stopped: false)
       end
 
-      def closed(reason, what, client:, relay_id:, qid:)
+      def closed(reason, what, client:, relay_id:, qid:, hook: false)
         case reason
-        when "answered_on_child" then Outcome.new(line: line(what, "answered on the child"), stopped: false)
-        when "child_gone" then Outcome.new(line: line(what, "not delivered (the child's worker is gone)"), stopped: false)
+        when "answered_on_child" then Outcome.new(line: line(what, "answered on the child", hook: hook), stopped: false)
+        when "child_gone"
+          Outcome.new(line: line(what, "not delivered (the child's worker is gone)", hook: hook), stopped: false)
         else
           # A Stop: the child's question stays open there.
           post(client, "closed", relay_id, qid, reason: "stopped")
-          Outcome.new(line: line(what, "still open (your turn was stopped)"), stopped: true)
+          Outcome.new(line: line(what, "still open (your turn was stopped)", hook: hook), stopped: true)
         end
       end
 
@@ -108,10 +140,16 @@ module Samagotchi
       def delivered(response, answer, fields, dismissed)
         return "not delivered (the child's worker is gone)" unless response
 
+        hook = fields[:kind] == HOOK_KIND
         case response.status
-        when 200 then dismissed ? "dismissed (denied)" : verdict(answer, fields)
+        when 200
+          # A dismissed hook question: the hook decides what no answer means.
+          return dismissed ? "dismissed" : answer.selected.join(", ") if hook
+
+          dismissed ? "dismissed (denied)" : verdict(answer, fields)
         when 409 then "answered on the child"
-        when 403 then "refused by the child (a parent agent may not allow it); it waits for the user there"
+        when 403
+          "refused by the child (a parent agent may not #{hook ? "pick it" : "allow it"}); it waits for the user there"
         else "not delivered (#{response.json&.fetch("error", nil) || response.status})"
         end
       end
@@ -134,7 +172,15 @@ module Samagotchi
         why.empty? ? "denied" : "denied (#{why.inspect})"
       end
 
-      def line(what, outcome) = "approval relayed to your user: #{what} → #{outcome}"
+      def line(what, outcome, hook: false)
+        "#{hook ? "hook question" : "approval"} relayed to your user: #{what} → #{outcome}"
+      end
+
+      # A hook card's header as the child asked it (Cost cap), or its hook.
+      def hook_what(fields)
+        header = fields.dig(:relay, :header).to_s
+        header.empty? ? fields[:hook].to_s : header
+      end
 
       # execute: git push origin main
       def what_text(facts)
@@ -151,6 +197,9 @@ module Samagotchi
       # (DelegateWait.relayed_outcomes). Every question is relayed once per
       # wait.
       class Others
+        # The kinds of question a relay may carry (DelegateRelay.relay? decides).
+        KINDS = [Guardrails::Approval::KIND, HOOK_KIND].freeze
+
         # @param parent_id [String]
         # @param except [String] the child waited on (its own approvals come
         #   through ReplyWait)
@@ -191,11 +240,16 @@ module Samagotchi
         #   oldest question first
         def waiting
           rows = SessionManager.children_of(@parent_id, state_dir: @state_dir).select do |row|
-            row[:id] != @except && row[:waiting] == Guardrails::Approval::KIND && !@done[row[:waiting_id].to_s]
+            row[:id] != @except && KINDS.include?(row[:waiting].to_s) && !@done[row[:waiting_id].to_s]
           end
           rows.filter_map do |row|
-            pending = Session.load(row[:id], state_dir: @state_dir).pending_question
-            [row[:id], pending] if pending && pending.id.to_s == row[:waiting_id].to_s
+            child = Session.load(row[:id], state_dir: @state_dir)
+            pending = child.pending_question
+            next nil unless pending && pending.id.to_s == row[:waiting_id].to_s
+            next nil unless DelegateRelay.relayable?(@relay, pending, strategy: Guardrails::ParentPolicy.for_session(child),
+                                                                      child_id: row[:id])
+
+            [row[:id], pending]
           rescue ArgumentError
             nil
           end.sort_by { |_, pending| pending.created_at.to_s }

data/lib/samagotchi/tools/delegate_wait.rb

@@ -82,7 +82,9 @@ module Samagotchi
                                           owner_grace: owner_grace, interject: others && -> { others.poll },
                                           turn: cursor.turn)
           left -= monotonic - started
-          unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
+          unless wait.status == :waiting_for_answer &&
+                 DelegateRelay.relayable?(relay, wait.question, strategy: Guardrails::ParentPolicy.for_session(wait.session),
+                                                                child_id: child_id)
             outcomes.concat(relayed_outcomes.delete(key) || [])
             movement = advance(peers.session_id, child_id, wait, state_dir: sd)
             if movement&.already_reported
@@ -213,6 +215,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 +227,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 +272,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 +309,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.88.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/public/notify.js

@@ -44,8 +44,10 @@ export function waitingOn(summary) {
 // waiting on directly is seen by its look at the others (DelegateRelay
 // OTHERS_EVERY, 2 s), and the relay reaches the page with the hub's next
 // scan (SessionHub SCAN_INTERVAL, 1 s): up to ~3 s. Only these approvals
-// wait; a child's approval nobody relays rings this late.
+// wait (and a child's hook question, which may be relayed too); one nobody
+// relays rings this late.
 export const RELAY_HOLD_MS = 3500;
+const RELAYED_KINDS = new Set(["approval", "hook"]);
 
 // What changed between two summaries of one session that needs the user.
 // @param prev the summary held before (null for a session not seen yet)
@@ -60,7 +62,9 @@ export function attentionFor(prev, next) {
     // Relayed to the parent already: the parent's card notifies.
     if (q.relayed_to) return null;
     const attention = { reason: questionReason(q), sessionId: next.id, key: `${next.id}:${q.id}` };
-    return next.parent_id && q.kind === "approval" ? { ...attention, holdMs: RELAY_HOLD_MS } : attention;
+    // A hook's question may be relayed too (when the parent may only deny it);
+    // one the parent's model answers rings as late, which does no harm.
+    return next.parent_id && RELAYED_KINDS.has(q.kind) ? { ...attention, holdMs: RELAY_HOLD_MS } : attention;
   }
   const card = next.pending_card;
   if (card && card.id && card.id !== prev?.pending_card?.id) {

data/lib/samagotchi/web/public/question_card.js

@@ -119,6 +119,8 @@ export function resultText(pq, { answer = null, cancelled = false, reason = "" }
   const relay = relayView(pq);
   if (cancelled && Object.hasOwn(CLOSED_PLAIN, reason)) return CLOSED_PLAIN[reason];
   if (cancelled && relay && reason !== "dismissed") return relayClosedText(relay, reason);
+  // A relayed hook question's dismissal: the hook decides what it means.
+  if (cancelled && relay && !approval) return "Dismissed";
   if (isContinue(pq)) return continueResultText({ answer, cancelled, reason });
   if (cancelled) {
     const label = approval ? "Denied" : "Cancelled";

data/lib/samagotchi/web/public/question_cards.js

@@ -17,7 +17,7 @@ import { diffTemplate } from "./diff_view.js";
 import { render } from "./vendor/lit-html.js";
 import {
   answerErrorText, approvalAllowed, approvalView, CONTINUE_REASON_PLACEHOLDER, deniedReason, isContinue, keepsAskingText,
-  nextCardAction, relayedToView, resultText, summaryText,
+  nextCardAction, relayedToView, relayView, resultText, summaryText,
 } from "./question_card.js";
 import { sessionHash } from "./route.js";
 import { clientLabel, isOwn } from "./turn_events.js";
@@ -92,9 +92,12 @@ export function createQuestionCards({
     if (approval) {
       card.appendChild(renderApprovalDetails(approval));
     } else {
+      // A delegate's hook question relayed here: who asks, then its own text.
+      const relay = relayView(pq);
+      if (relay) card.appendChild(renderDelegateLine(relay));
       const q = doc.createElement("div");
       q.className = "question-text";
-      q.textContent = pq.question || "";
+      q.textContent = (relay && pq.relay.asked) || pq.question || "";
       card.appendChild(q);
     }
 
@@ -273,28 +276,32 @@ export function createQuestionCards({
     card.appendChild(err);
   }
 
+  // "delegate ab12 · its task", the name linked to its session (a relayed
+  // approval's or hook question's; relayView).
+  function renderDelegateLine(delegate) {
+    const who = doc.createElement("div");
+    who.className = "approval-delegate";
+    const label = doc.createElement("span");
+    label.className = "approval-label";
+    label.textContent = "delegate ";
+    who.appendChild(label);
+    const name = doc.createElement("a");
+    name.className = "approval-delegate-link";
+    name.href = sessionHash(delegate.childId);
+    name.title = "Open the delegate's session";
+    name.textContent = delegate.who;
+    who.appendChild(name);
+    if (delegate.task) who.appendChild(doc.createTextNode(` · ${delegate.task}`));
+    return who;
+  }
+
   // The tool, the command (or paths, or args) as code, where and why; no
   // code box when there is nothing to show.
   function renderApprovalDetails(view) {
     const box = doc.createElement("div");
     box.className = "approval-details";
     // A delegate's approval: who asks, and its task.
-    if (view.delegate) {
-      const who = doc.createElement("div");
-      who.className = "approval-delegate";
-      const label = doc.createElement("span");
-      label.className = "approval-label";
-      label.textContent = "delegate ";
-      who.appendChild(label);
-      const name = doc.createElement("a");
-      name.className = "approval-delegate-link";
-      name.href = sessionHash(view.delegate.childId);
-      name.title = "Open the delegate's session";
-      name.textContent = view.delegate.who;
-      who.appendChild(name);
-      if (view.delegate.task) who.appendChild(doc.createTextNode(` · ${view.delegate.task}`));
-      box.appendChild(who);
-    }
+    if (view.delegate) box.appendChild(renderDelegateLine(view.delegate));
     const tool = doc.createElement("div");
     tool.className = "approval-tool";
     tool.textContent = view.tool;

data/lib/samagotchi/worker.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require_relative "client_id"
 require_relative "config"
 require_relative "engine"
+require_relative "guardrails/parent_policy"
 require_relative "events"
 require_relative "session"
 require_relative "session_inbox"
@@ -308,6 +309,7 @@ module Samagotchi
       # What failed to load and what plugins showed as they loaded, now that
       # a UI can be there (a late one gets them in the snapshot).
       @engine.announce_load_events!
+      announce_session_warnings
       @idle_exit = WorkerIdleExit.new(
         engine: @engine, bridge: @bridge,
         timeout_minutes: @idle_exit_minutes || SessionManager.config_idle_exit_minutes,
@@ -468,6 +470,16 @@ module Samagotchi
       save_or_log(:interrupted_turn) { save_session }
     end
 
+    # A saved parent_answers that isn't a level reads as hard on every
+    # answer without a word; said once here, as the session loads.
+    def announce_session_warnings
+      value = @session.parent_answers
+      return unless Guardrails::ParentPolicy.unknown_level?(value)
+
+      @engine.announce({ type: :guardrail_warning, label: "parent_answers",
+                         message: "parent_answers #{value.inspect} in session #{@session_id} isn't hard/standard/soft; hard applies" })
+    end
+
     # A question saved by a worker that died while it waited (an
     # ask_user_question, an approval, a hook's question): the turn that
     # asked is gone, so nobody can answer it, and left in the file it
@@ -600,7 +612,9 @@ module Samagotchi
       budget_notice if state == :budget
       return false unless state == :due
 
-      reports, = take_child_reports
+      # Unresolved: a relay among them opens its card at the turn's first
+      # boundary, on the turn thread (a Stop closes it).
+      reports, = take_child_reports(resolve: false)
       # The turn must not generate with nothing to say: the drain gets this
       # exact list at its first boundary.
       return false if reports.empty?
@@ -794,7 +808,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 +824,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]
@@ -1003,19 +1025,26 @@ module Samagotchi
     end
 
     # The Engine published a question (after the question desk saved it).
-    # In a turn that reports to the parent, the model's own question and
-    # the step-limit continue ring it; approvals and hooks' questions are
-    # the user's, on this session's card.
+    # In a turn that reports to the parent, the model's own question, the
+    # step-limit continue and a hook's question ring it (the parent reports
+    # or relays a hook's: ChildReports). Approvals don't: the relay takes
+    # them while the parent waits. Nor does a card relayed from this
+    # session's own child (relay set): the hop is the parent's wait.
     def ring_question(event)
       return unless @reporting_turn
 
-      kind = event.dig(:pending_question, :kind).to_s
-      return unless ["", ContinueOffer::KIND].include?(kind)
+      pending = event[:pending_question] || {}
+      kind = pending[:kind].to_s
+      return unless RINGING_KINDS.include?(kind)
+      return if pending[:relay]
 
       ChildRing.ring(@session, why: "question", state_dir: @state_dir)
       @asked_parent = true
     end
 
+    # The kinds of question that ring a delegate child's parent (#ring_question).
+    RINGING_KINDS = ["", ContinueOffer::KIND, "hook"].freeze
+
     # WorkerInbound.save_or_log: a failed save between turns is logged.
     def save_or_log(at, &) = WorkerInbound.save_or_log(at, &)
 
@@ -1105,17 +1134,37 @@ module Samagotchi
     # the turn as its own).
     # @return [Array(Array<ChildReports::Report>, Hash|nil)] the reports
     #   and the mark of their message
-    def take_child_reports
+    # A report whose question goes to the parent's user is relayed here
+    # (ChildReports#resolve), before the boundary announces or merges
+    # anything; one whose card a Stop closed is held back until a human's
+    # input (no wake turn re-offers it at once; other wakes go on).
+    # +resolve+ false: a wake turn's take before the turn starts.
+    def take_child_reports(resolve: true)
       if (reports = @wakes.take_handed)
-        return [reports, { turn_start: true, turn_id: @turn_id }.compact]
+        return [resolve_relays(reports), { turn_start: true, turn_id: @turn_id }.compact]
       end
 
-      [@child_reports.take, nil]
+      taken = @child_reports.take
+      [resolve ? resolve_relays(taken) : taken, nil]
     rescue StandardError => e
       Log.warn(:worker, "delegate_reports_failed", error: e.class.name, msg: e.message)
       [[], nil]
     end
 
+    def resolve_relays(reports)
+      return reports if reports.none?(&:relay)
+
+      relay = @engine.relay_peer
+      stopped = false
+      reports.filter_map do |report|
+        next report unless report.relay
+        # The turn stopped on an earlier card: no more cards in it.
+        next @child_reports.hold_back(report) if stopped
+
+        @child_reports.resolve(report, relay: relay).tap { |resolved| stopped = resolved.nil? }
+      end
+    end
+
     # Check again with the event log held, which the Bridge holds while it
     # queues a POST /turn, then close the Bridge's intake so no client can
     # queue one after the check, and stop the idle jobs (reminder callback,
@@ -1237,6 +1286,7 @@ module Samagotchi
 
       ArchiveStore.user_input(@session_id, state_dir: @state_dir)
       @wakes.human_input!(interactive: ClientId.interactive?(client_id))
+      @child_reports&.release_holds
     end
 
     def stopped_on_disk?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.86.0
+  version: 0.88.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