samagotchi 0.91.0 → 0.93.0

data/lib/samagotchi/tool_response.rb

@@ -28,20 +28,42 @@ module Samagotchi
 
     # Runs +calls+ in order (ToolRunner#run each), yielding each run and its
     # index as it finishes. +emit+ takes the dispatch events, the runner's
-    # own go to +on_stream_event+.
+    # own go to +on_stream_event+. An Interrupt (Ctrl-C) mid-batch yields an
+    # #interrupted run for every call left (the one it cut short too), so
+    # the loop's conversation answers each call, then goes on up: the turn
+    # keeps its progress (Engine#ctrl_c_messages).
     # @return [Array<ToolRun>] the runs
     def run_batch(runner, calls, iteration:, emit:, on_stream_event:, cap:)
+      # Before anything can be interrupted: the rescue counts it.
+      runs = []
       emit.call({ type: :tool_dispatch_started, iteration: iteration, call_count: calls.length })
-      runs = calls.each_with_index.map do |call, index|
-        run = runner.run(call, iteration: iteration, call_index: index + 1, call_count: calls.length,
-                               on_stream_event: on_stream_event, max_tool_output_chars: cap)
-        yield run, index if block_given?
-        run
+      calls.each_with_index do |call, index|
+        runs << runner.run(call, iteration: iteration, call_index: index + 1, call_count: calls.length,
+                                 on_stream_event: on_stream_event, max_tool_output_chars: cap)
+        yield runs.last, index if block_given?
       end
       emit.call({ type: :tool_dispatch_completed, iteration: iteration, call_count: calls.length })
       runs
+    rescue Interrupt
+      calls.each_with_index.drop(runs.size).each { |call, index| yield interrupted(call[:name]), index } if block_given?
+      raise
     end
 
+    # The result of a call an Interrupt cut short (or never started): the
+    # model reads that it may have partly run.
+    def interrupted(name)
+      text = interrupted_text(name)
+      ToolRun.new(output: text, capped_output: text)
+    end
+
+    INTERRUPTED = "Interrupted (Ctrl-C) before it returned: it may have partly run."
+
+    def interrupted_text(name) = "[#{name}] #{INTERRUPTED}"
+
+    # Whether +content+ is an #interrupted result, whatever tool it names
+    # (an aliased call's saved name is the model's, the text the tool's).
+    def interrupted_text?(content) = content.to_s.match?(/\A\[[^\]\s]+\] #{Regexp.escape(INTERRUPTED)}\z/)
+
     # The runs' activity, for the turn's tool list (none for a call whose
     # dispatcher raised).
     def activities(runs)

data/lib/samagotchi/tools/delegate.rb

@@ -234,11 +234,11 @@ module Samagotchi
         DelegateWait.mark_seen(parent.id, child, state_dir: state_dir)
         delivered = SessionManager.deliver_turn(id, prompt: task, client_id: "#{ClientId::DELEGATE_PREFIX}#{parent.id[0, 8]}",
                                                     state_dir: state_dir)
-        case delivered[:status]
+        case delivered.status
         when :accepted
-          DelegateWait.mark_turn(parent.id, id, follow_up_turn(id, delivered[:ack], state_dir: state_dir), state_dir: state_dir)
+          DelegateWait.mark_turn(parent.id, id, follow_up_turn(id, delivered.enqueued_id, state_dir: state_dir), state_dir: state_dir)
           id
-        when :refused then "Error: session #{id[0, 8]} refused the message (#{delivered.dig(:ack, "error")})"
+        when :refused then "Error: session #{id[0, 8]} refused the message (#{delivered.error})"
         when :timeout then "Error: the worker of session #{id[0, 8]} did not answer in time, so the message was not sent"
         else "Error: the message to session #{id[0, 8]} could not be written"
         end
@@ -251,24 +251,24 @@ module Samagotchi
 
       # The child's turn a delivered follow-up joins, for the wait
       # (DelegateCursor#turn): the running turn's (its checkpoint mark), the
-      # follow-up merging into it; else the ack's enqueued_id, the follow-up
-      # running as a turn of its own. Only from a worker that names
-      # turn_ids; nil otherwise, or when the running turn has no id (a
-      # delegate's first turn): the wait takes the next reply.
+      # follow-up merging into it; else the delivery's +enqueued_id+, the
+      # follow-up running as a turn of its own. Only
+      # from a worker that names turn_ids; nil otherwise, or when the
+      # running turn has no id (a delegate's first turn): the wait takes the
+      # next reply.
       # A follow-up steered into a turn that ended before it merged runs as
       # its own turn, yet the wait is on the ended one (LOW, as before).
       # One the child's idle look missed being merged into a turn starting
       # then never runs as its own: ReplyWait falls back to that turn's
       # reply (merged_elsewhere?).
       # @return [String, nil]
-      def self.follow_up_turn(id, ack, state_dir:)
+      def self.follow_up_turn(id, enqueued_id, state_dir:)
         return nil unless ReplyWait.turn_ids?(Session.session_dir(id, state_dir: state_dir))
 
         child = Session.load(id, state_dir: state_dir)
         return child.interrupted_turn&.enqueued_id if child.status == Session::STATUS_RUNNING
 
-        enqueued_id = ack.is_a?(Hash) ? (ack["enqueued_id"] || ack[:enqueued_id]) : nil
-        enqueued_id.to_s.empty? ? nil : enqueued_id.to_s
+        enqueued_id
       rescue ArgumentError
         nil
       end

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -4,6 +4,7 @@ require "json"
 require "fileutils"
 require_relative "../atomic_file"
 require_relative "../session"
+require_relative "../reply_wait"
 
 module Samagotchi
   module Tools
@@ -14,32 +15,54 @@ module Samagotchi
     # of the child's turn the last follow-up went to (Delegate.follow_up),
     # whose own reply a wait takes (ReplyWait's turn:); nil once that turn
     # was reported, or when unknown (a new child, an older worker).
-    #   +report_claim+: a report reserved until the parent's turn is settled.
+    #   +report_claim+: a report reserved until the parent's turn is settled
+    # (ReportClaim).
     DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn, :report_claim) do
       def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil, report_claim: nil) = super
 
       def self.empty = new
 
-      # @param baseline [Hash, nil] ReplyWait.baseline_of's
+      # The cursor with no report reserved: what it is once the reserving
+      # turn is settled, and how two cursors compare apart from a claim.
+      def without_claim = with(report_claim: nil)
+
+      # @param baseline [ReplyWait::Baseline, nil] ReplyWait.baseline_of's
       def with_baseline(baseline)
-        b = baseline || {}
-        with(messages: b[:messages], question_id: b[:question_id], last_turn: b[:last_turn])
+        with(messages: baseline&.messages, question_id: baseline&.question_id, last_turn: baseline&.last_turn)
       end
 
-      # @return [Hash, nil] ReplyWait's baseline:, nil when none was taken
+      # @return [ReplyWait::Baseline, nil] ReplyWait's baseline:, nil when
+      #   none was taken
       def baseline
         return nil if messages.nil?
 
-        { messages: messages, question_id: question_id, last_turn: last_turn }
+        ReplyWait::Baseline.new(messages: messages, question_id: question_id, last_turn: last_turn)
       end
 
-      def to_json_hash = to_h.transform_keys(&:to_s).compact
+      def to_json_hash = to_h.merge(report_claim: report_claim&.to_json_hash).transform_keys(&:to_s).compact
 
       def self.from_json_hash(data)
         return empty unless data.is_a?(Hash)
 
         new(reply_file: data["reply_file"], last_turn: data["last_turn"], question_id: data["question_id"],
-            messages: data["messages"], turn: data["turn"], report_claim: data["report_claim"])
+            messages: data["messages"], turn: data["turn"], report_claim: ReportClaim.from_json_hash(data["report_claim"]))
+      end
+    end
+
+    # A delegate report reserved in the parent's cursor (ChildReports) until
+    # the parent's turn that took it is kept or rolled back: +id+ the
+    # claim's id (the taking turn's Report#claim_id), +file+ the reply file
+    # reported (nil for a question), +cursor+ the DelegateCursor the report
+    # moves the parent to once kept (its own claim empty). In delegates.json
+    # it is {"id", "file", "cursor"}, the file's key kept even when nil.
+    ReportClaim = Data.define(:id, :file, :cursor) do
+      def to_json_hash = { "id" => id, "file" => file, "cursor" => cursor.to_json_hash }
+
+      # @return [ReportClaim, nil] nil for no claim (or not a Hash)
+      def self.from_json_hash(data)
+        return nil unless data.is_a?(Hash)
+
+        new(id: data["id"], file: data["file"], cursor: DelegateCursor.from_json_hash(data["cursor"]))
       end
     end
 
@@ -77,6 +100,7 @@ module Samagotchi
       end
 
       # Reserve a report only if the cursor read to build it is still current.
+      # @param claim [ReportClaim]
       # @return [DelegateCursor, nil] the reserved cursor, or nil if another path moved it
       def claim_report(parent_id, child_id, expected:, claim:, state_dir:)
         locked(parent_id, state_dir: state_dir) do

data/lib/samagotchi/tools/delegate_relay.rb

@@ -85,7 +85,7 @@ module Samagotchi
 
         fields = Relay.card(child, question, relay_id: relay_id, more: more)
         answer = relay.open_question(fields, watch: watch(child_id, qid, state_dir))
-        settle(answer, fields, client: client, desk: desk, relay_id: relay_id, qid: qid)
+        settle(answer, fields, label: label(question), client: client, desk: desk, relay_id: relay_id, qid: qid)
       ensure
         # A relay that failed before it settled closes, so the desk (which
         # prunes only settled ones) keeps none open; a settled one stays.
@@ -108,12 +108,11 @@ module Samagotchi
       end
 
       # Record the parent's answer, tell the child, and say what came of it.
-      def settle(answer, fields, client:, desk:, relay_id:, qid:)
-        what = fields[:kind] == HOOK_KIND ? hook_what(fields) : what_text(fields[:approval])
-        hook = fields[:kind] == HOOK_KIND
+      # @param label [String] the outcome line's start (#label)
+      def settle(answer, fields, label:, client:, desk:, relay_id:, qid:)
         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, hook: hook)
+          return closed(answer[:reason].to_s, label, client: client, relay_id: relay_id, qid: qid)
         end
 
         dismissed = !answer.is_a?(QuestionAnswer)
@@ -121,18 +120,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), hook: hook), stopped: false)
+        Outcome.new(line: line(label, delivered(response, answer, fields, dismissed)), stopped: false)
       end
 
-      def closed(reason, what, client:, relay_id:, qid:, hook: false)
+      def closed(reason, label, client:, relay_id:, qid:)
         case reason
-        when "answered_on_child" then Outcome.new(line: line(what, "answered on the child", hook: hook), stopped: false)
+        when "answered_on_child" then Outcome.new(line: line(label, "answered on the child"), stopped: false)
         when "child_gone"
-          Outcome.new(line: line(what, "not delivered (the child's worker is gone)", hook: hook), stopped: false)
+          Outcome.new(line: line(label, "not delivered (the child's worker is gone)"), 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)", hook: hook), stopped: true)
+          Outcome.new(line: line(label, "still open (your turn was stopped)"), stopped: true)
         end
       end
 
@@ -172,14 +171,30 @@ module Samagotchi
         why.empty? ? "denied" : "denied (#{why.inspect})"
       end
 
-      def line(what, outcome, hook: false)
-        "#{hook ? "hook question" : "approval"} relayed to your user: #{what} → #{outcome}"
+      # One relayed question's outcome line: #label → +outcome+.
+      def line(label, outcome) = "#{label} → #{outcome}"
+
+      # What an outcome line starts with: "hook question relayed to your
+      # user: Cost cap", "approval relayed to your user: execute: git push".
+      # @param question [PendingQuestion] the child's
+      def label(question)
+        "#{question.kind.to_s == HOOK_KIND ? "hook question" : "approval"} relayed to your user: #{what(question)}"
+      end
+
+      # What a relayed question is about, as its card has it (Relay.card): a
+      # hook's header as the asking hook gave it (kept down a chain: a relay
+      # of a relay), else its hook; an approval's call (#what_text).
+      # @param question [PendingQuestion] the child's
+      def what(question)
+        return what_text(symbolized(question.approval)) unless question.kind.to_s == HOOK_KIND
+
+        inner = symbolized(question.relay, nil)
+        header = (inner ? inner[:header] : question.header).to_s
+        header.empty? ? question.hook.to_s : header
       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
+      def symbolized(value, none = {})
+        value.is_a?(Hash) ? Relay.deep_symbolize(value) : none
       end
 
       # execute: git push origin main

data/lib/samagotchi/tools/delegate_wait.rb

@@ -69,7 +69,7 @@ module Samagotchi
         cursor = DelegateCursors.get(peers.session_id, child_id, state_dir: sd)
         report_claim = cursor.report_claim
         if report_claim
-          cursor = DelegateCursor.from_json_hash(report_claim["cursor"]).with(report_claim: report_claim)
+          cursor = report_claim.cursor.with(report_claim: report_claim)
         end
 
         baseline = cursor.baseline
@@ -88,10 +88,10 @@ module Samagotchi
             outcomes.concat(relayed_outcomes.delete(key) || [])
             movement = advance(peers.session_id, child_id, wait, state_dir: sd)
             if movement&.already_reported
-              file = movement.cursor.report_claim&.fetch("file", nil) || wait.file
+              file = movement.cursor.report_claim&.file || wait.file
               return already_reported_result(child_id, file, state_dir: sd)
             end
-            return already_reported_result(child_id, report_claim["file"], state_dir: sd) if report_claim && wait.status == :timeout
+            return already_reported_result(child_id, report_claim.file, state_dir: sd) if report_claim && wait.status == :timeout
 
             text = with_outcomes(finish(wait, child_id, timeout: timeout, reports: reports), outcomes)
             return RefText.wrap(text, reply_path(child_id, wait, state_dir: sd))
@@ -179,7 +179,7 @@ module Samagotchi
 
         already_reported = false
         cursor = DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |current|
-          if (current.report_claim && current.report_claim["file"] == wait.file) ||
+          if (current.report_claim && current.report_claim.file == wait.file) ||
              (wait.status == :done && current.reply_file == wait.file)
             already_reported = true
             next current

data/lib/samagotchi/tools/task_runtime.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "shellwords"
 require "time"
 require_relative "../atomic_file"
+require_relative "../child_env"
 require_relative "../log"
 require_relative "../process_group"
 require_relative "shell"
@@ -29,8 +30,7 @@ module Samagotchi
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
-      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING
-                           SAMAGOTCHI_SESSION_REASONING_HISTORY].freeze
+      MARKER_ENV_KEYS = ChildEnv::SESSION_MARKERS
       # task_wait and task_get add it to a task the user stopped (the web's
       # stop-task button), so the model doesn't rerun the job.
       # A record whose pid isn't a process group chi started (missing, 0, 1,

data/lib/samagotchi/turn_checkpoint.rb

@@ -91,16 +91,25 @@ module Samagotchi
     end
     private_class_method :settled_record
 
+    # A command's status (its command_ran's) as a settled outcome; any
+    # other status (busy, dropped) is a cancel for that reason.
+    COMMAND_OUTCOMES = { "ok" => "completed", "error" => "failed" }.freeze
+    # Its record's origin: no turn ran (ParentReport says "the command").
+    COMMAND_ORIGIN = "command"
+
     # A file-delivered command ends its sender's wait without running a
-    # turn. Keep a terminal outcome under the same per-input settled path.
-    def self.record_command_outcome(session_dir, enqueued_id)
+    # turn. Keep a terminal outcome under the same per-input settled path:
+    # +status+ is its command_ran's ("ok", "error", "busy", "dropped" at a
+    # teardown), so the wait reads completed, failed, or canceled with that
+    # reason.
+    def self.record_command_outcome(session_dir, enqueued_id, status:)
       id = enqueued_id.to_s
       return if id.empty? || !SessionInbox::ENQUEUED_ID_NAME.match?(id)
 
-      dir = File.join(session_dir, SessionInbox::INPUT_DIR, SETTLED_DIR)
-      FileUtils.mkdir_p(dir)
-      record = LastTurn.new(outcome: "completed", ended_at: Time.now.iso8601(3), enqueued_id: id)
-      AtomicFile.write(File.join(dir, id), JSON.generate(record.to_file))
+      outcome = COMMAND_OUTCOMES.fetch(status.to_s, "canceled")
+      record = LastTurn.new(outcome: outcome, cancel_reason: (status.to_s if outcome == "canceled"),
+                            ended_at: Time.now.iso8601(3), origin: COMMAND_ORIGIN, enqueued_id: id)
+      write_settled(session_dir, id, record)
     rescue SystemCallError, IOError => e
       Log.warn(:worker, "command_outcome_write_failed", error: e.class.name, msg: e.message, enqueued_id: id)
     end
@@ -109,14 +118,18 @@ module Samagotchi
       id = mark.enqueued_id.to_s
       return unless SessionInbox::ENQUEUED_ID_NAME.match?(id)
 
-      dir = File.join(session_dir, SessionInbox::INPUT_DIR, SETTLED_DIR)
-      FileUtils.mkdir_p(dir)
-      record = settled_record(id, ended_at: Time.now.iso8601(3), seconds: seconds)
-      AtomicFile.write(File.join(dir, id), JSON.generate(record.to_file))
+      write_settled(session_dir, id, settled_record(id, ended_at: Time.now.iso8601(3), seconds: seconds))
     rescue SystemCallError => e
       # The settle goes on; a wait for that turn runs to its timeout.
       Log.warn(:worker, "settled_turn_write_failed", error: e.class.name, msg: e.message)
     end
+
+    def self.write_settled(session_dir, id, record)
+      dir = File.join(session_dir, SessionInbox::INPUT_DIR, SETTLED_DIR)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, id), JSON.generate(record.to_file))
+    end
+    private_class_method :write_settled
     private_class_method :record_settled
 
     # @param session [Session] the worker's session (saved as a whole)

data/lib/samagotchi/version.rb

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