samagotchi 0.90.0 → 0.92.0

data/lib/samagotchi/worker_inbound.rb

@@ -11,6 +11,7 @@ require_relative "context_note"
 require_relative "log"
 require_relative "session"
 require_relative "session_inbox"
+require_relative "tools/task_record"
 require_relative "worker_wakes"
 
 module Samagotchi
@@ -51,6 +52,19 @@ module Samagotchi
       # that agrees closes the round and counts toward session.max_wakes only.
       def peer_turn? = peer? && !delivery.agreed
       def origin = { client_id: "#{ClientId::CONTEXT_PREFIX}#{name}" }
+      # The plain note #unmark_wake puts back.
+      def note = delivery.note
+    end
+
+    # A task finish wake turn to run (TaskWatch, TaskFinishNote): its wake
+    # note is in the conversation as the start of the turn +turn_id+;
+    # +plain_note+ is the same note without the turn start or the ask, which
+    # #unmark_wake puts back after a failed or restored wake turn. +id+: the
+    # finished task it runs for (the others finished with it are plain notes).
+    TaskWake = Data.define(:id, :turn_id, :plain_note) do
+      def name = "task #{Tools::TaskRecord.short_id(id)}"
+      def origin = { client_id: "#{ClientId::TASK_PREFIX}#{id}" }
+      def note = plain_note
     end
 
     # A save between turns (the turn's own, a command's, the notes', the
@@ -144,13 +158,13 @@ module Samagotchi
 
     # A failed wake turn kept nothing but its note: the note goes back to
     # a plain note (no turn start, the background wording), so a reload
-    # draws no empty turn for it.
-    def unmark_wake(context_wake)
+    # draws no empty turn for it. +wake+: a ContextWake or a TaskWake.
+    def unmark_wake(wake)
       messages = @engine.messages_checkpoint
-      index = messages.index { |m| m[:turn_start] && m[:turn_id] == context_wake.turn_id }
+      index = messages.index { |m| m[:turn_start] && m[:turn_id] == wake.turn_id }
       return unless index
 
-      messages[index] = ContextNote.message(**context_wake.delivery.note)
+      messages[index] = ContextNote.message(**wake.note)
       @engine.rollback_to(messages)
     end
 

data/lib/samagotchi/worker_task_wakes.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "child_reports"
+require_relative "kernel_loop"
+require_relative "log"
+require_relative "task_finish_note"
+require_relative "task_watch"
+require_relative "tools/task_runtime"
+require_relative "worker_inbound"
+require_relative "worker_wakes"
+
+module Samagotchi
+  # A worker's finish wake (docs/internals/background-tasks.md, Finish
+  # wake): its TaskWatch, fed by the Engine's raw events (#observe), and
+  # the TASK FINISHED notes for the tasks that finished unseen. #take
+  # writes them and hands back the wake turn to run, which the Worker runs
+  # (Worker#run_wake); #absorb gives them to a prompt's turn as plain notes.
+  # On the loop's thread, like WorkerInbound.
+  class WorkerTaskWakes
+    # @return [TaskWatch]
+    attr_reader :watch
+
+    # @param wakes [WorkerWakes] the wake budget a task's wake asks
+    # @param awaiting_continue [#call] whether a continue offer waits
+    # @param idle [#call] nothing queued and no exit asked for: a finish
+    #   may start a turn
+    # @param save [#call] saves the session (a failure is the callee's to log)
+    def initialize(engine:, session:, wakes:, awaiting_continue:, idle:, save:)
+      @engine = engine
+      @session = session
+      @wakes = wakes
+      @awaiting_continue = awaiting_continue
+      @idle = idle
+      @save = save
+      @watch = TaskWatch.new
+    end
+
+    # The Engine's raw events feed the task watch (session.task_wakes not
+    # off): a result that started a task or showed its end, a turn's start,
+    # a user's Stop of it (M5).
+    def observe(event)
+      case event[:type]
+      when :tool_call_completed then @watch.observe(event) unless TaskWatch.mode == "off"
+      when :turn_started then @watch.turn_started
+      when :turn_canceled then @watch.turn_canceled(event[:cancellation_reason])
+      end
+    end
+
+    # Whether a finished task would start a wake turn now: the Engine skips
+    # the turn-end warm-up then (next_turn_waiting).
+    def due?
+      TaskWatch.mode == "wake" && @watch.any? && @wakes.task_open?(awaiting_continue: @awaiting_continue.call) &&
+        @watch.finished?
+    end
+
+    # The background tasks this session started that finished unseen
+    # (TaskWatch#take_finished), each as a TASK FINISHED note
+    # (TaskFinishNote): the first one not note-only starts a wake turn from
+    # task:<id> when session.task_wakes is wake, nothing is queued, no exit
+    # was asked for and the wake budget is open (WorkerWakes#task_open?);
+    # the others, and every one otherwise, are plain notes for the next
+    # turn (M2). A spent budget is announced once.
+    # @return [WorkerInbound::TaskWake, nil] the wake turn to run now
+    def take
+      return nil if @wakes.in_grace? || !@watch.any?
+
+      finished = take_finished
+      return nil if finished.empty?
+
+      waking = finished.find { |entry, _| !entry.note_only } if wake_open?
+      task_wake = note_finished(finished, waking: waking)
+      return nil if task_wake == :failed
+
+      @save.call
+      return task_wake if task_wake
+
+      budget_notice(finished.count { |entry, _| !entry.note_only }) if TaskWatch.mode == "wake" && @wakes.spent?
+      nil
+    end
+
+    # Before a prompt's turn: the finished tasks join it as plain notes.
+    def absorb
+      return unless @watch.any?
+
+      finished = take_finished
+      return if finished.empty?
+      return if note_finished(finished) == :failed
+
+      @save.call
+    end
+
+    private
+
+    # Each finished task's note into the conversation: +waking+'s as the
+    # wake turn's start, the others plain. A note that can't be written (a
+    # log that can't be read, say) puts it and the ones after it back in
+    # the watch for the next look.
+    # @return [WorkerInbound::TaskWake, nil, :failed]
+    def note_finished(finished, waking: nil)
+      written = []
+      (finished - [waking]).each do |entry, record|
+        add_note(entry, record)
+        written << entry
+      end
+      waking && add_wake_note(*waking)
+    rescue StandardError => e
+      Log.warn(:worker, "task_note_failed", error: e.class.name, msg: e.message)
+      @watch.put_back(finished.map(&:first) - written)
+      :failed
+    end
+
+    # Only the tasks the conversation still holds (a !rollback, a restored
+    # turn may have dropped the result that started one). A failure to
+    # read them is logged and counted (TaskWatch#look_failed: past
+    # TaskWatch::MAX_FAILURES they no longer hold the worker up): they wait
+    # for the next look.
+    def take_finished
+      @watch.take_finished(keep: Tools::TaskRuntime.created_ids_in(@engine.messages_checkpoint))
+    rescue StandardError => e
+      Log.warn(:worker, "task_watch_failed", error: e.class.name, msg: e.message)
+      @watch.look_failed
+      []
+    end
+
+    def wake_open?
+      TaskWatch.mode == "wake" && @idle.call && @wakes.task_open?(awaiting_continue: @awaiting_continue.call)
+    end
+
+    def note(entry, record, wake:, turn_id: nil)
+      TaskFinishNote.note(record, limit_sec: entry.limit_sec, wake: wake, turn_id: turn_id,
+                                  cap: KernelLoop.resolve_output_char_cap(nil))
+    end
+
+    def add_note(entry, record)
+      @engine.add_context_note(@session, note(entry, record, wake: false))
+    end
+
+    # The wake note, in the conversation as the wake turn's first message
+    # (before TurnFlow#before_prompt_turn, so a restore keeps it).
+    # @return [WorkerInbound::TaskWake]
+    def add_wake_note(entry, record)
+      turn_id = SecureRandom.uuid
+      @engine.add_context_note(@session, note(entry, record, wake: true, turn_id: turn_id))
+      WorkerInbound::TaskWake.new(id: entry.id, turn_id: turn_id, plain_note: note(entry, record, wake: false))
+    end
+
+    # The wake budget is spent: the UIs hear once that finished tasks wait
+    # as notes (one notice per stretch, shared with the other kinds).
+    def budget_notice(count)
+      return unless count.positive? && @wakes.notice_budget!
+
+      @engine.announce(type: :hook_notice, hook: "task", level: :info, between_turns: true,
+                       text: "#{count} finished background task#{"s" if count != 1} noted; the model reads " \
+                             "#{count == 1 ? "it" : "them"} with your next message " \
+                             "(#{@wakes.max} wake turn#{"s" if @wakes.max != 1} in a row, #{ChildRing::MAX_WAKES_KEY})")
+    end
+  end
+end

data/lib/samagotchi/worker_wakes.rb

@@ -6,10 +6,10 @@ require_relative "child_reports"
 
 module Samagotchi
   # A worker's wake budget: turns nobody typed (a delegate report's wake
-  # turn, an attached context source's) run only past the start grace, at
-  # most session.max_wakes in a row with no human input, and not after a
-  # failed one until a human's input (a provider outage doesn't loop).
-  # Shared by both kinds of wake; the Worker asks it before each and tells
+  # turn, a finished background task's, an attached context source's) run
+  # only past the start grace, at most session.max_wakes in a row with no
+  # human input, and not after a failed one until a human's input (a
+  # provider outage doesn't loop). Shared by every kind of wake; the Worker asks it before each and tells
   # it what happened. It also holds the reports a delegate wake turn was
   # started for until the turn's first boundary takes them (#hand_over,
   # #take_handed).
@@ -110,6 +110,13 @@ module Samagotchi
       true
     end
 
+    # For a background task that finished unseen (TaskWatch): no continue
+    # offer, not paused, past the start grace and under the budget. #count!
+    # when its wake turn starts.
+    def task_open?(awaiting_continue:)
+      !@paused && !awaiting_continue && !in_grace? && @in_a_row < max
+    end
+
     # A wake turn starts; +peer+: for a peer's answer, which counts toward
     # both budgets. @return [Integer] the wake turns in a row now
     def count!(peer: false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.90.0
+  version: 0.92.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -204,6 +204,8 @@ files:
 - lib/samagotchi/bundle_command/check.rb
 - lib/samagotchi/bundle_command/scaffold.rb
 - lib/samagotchi/bundle_command/test_run.rb
+- lib/samagotchi/bundle_command/try/command.rb
+- lib/samagotchi/bundle_command/try/render.rb
 - lib/samagotchi/bundle_command/try/run.rb
 - lib/samagotchi/bundle_command/try/sandbox.rb
 - lib/samagotchi/bundle_command/try/trace.rb
@@ -263,6 +265,7 @@ files:
 - lib/samagotchi/bundles/system/self_map.md
 - lib/samagotchi/cache_confirm.rb
 - lib/samagotchi/cancellation_controller.rb
+- lib/samagotchi/child_env.rb
 - lib/samagotchi/child_move.rb
 - lib/samagotchi/child_reports.rb
 - lib/samagotchi/children_status.rb
@@ -492,6 +495,7 @@ files:
 - lib/samagotchi/reply_wait.rb
 - lib/samagotchi/row_refs.rb
 - lib/samagotchi/sampling_settings.rb
+- lib/samagotchi/sandbox_layout.rb
 - lib/samagotchi/self_report.rb
 - lib/samagotchi/send_command.rb
 - lib/samagotchi/served_model.rb
@@ -520,6 +524,8 @@ files:
 - lib/samagotchi/steer_cut.rb
 - lib/samagotchi/steer_cut_after.rb
 - lib/samagotchi/system_prompt.rb
+- lib/samagotchi/task_finish_note.rb
+- lib/samagotchi/task_watch.rb
 - lib/samagotchi/terminal_ui.rb
 - lib/samagotchi/terminal_ui/attach_launcher.rb
 - lib/samagotchi/terminal_ui/attached_loop.rb
@@ -741,6 +747,7 @@ files:
 - lib/samagotchi/worker_inbound.rb
 - lib/samagotchi/worker_sidecar.rb
 - lib/samagotchi/worker_signals.rb
+- lib/samagotchi/worker_task_wakes.rb
 - lib/samagotchi/worker_wakes.rb
 - lib/samagotchi/yaml_lines.rb
 homepage: https://github.com/dm1try/samagotchi