samagotchi 0.62.0 → 0.64.0

data/lib/samagotchi/terminal_ui.rb

@@ -25,6 +25,7 @@ require_relative "tools/memory"
 require_relative "output_formatter"
 require_relative "turn_flow"
 require_relative "session_commands"
+require_relative "composer_route"
 require_relative "terminal_ui/attached_view"
 require_relative "terminal_ui/between_turns"
 require_relative "terminal_ui/event_renderer"
@@ -121,6 +122,7 @@ module Samagotchi
 
       claim_session!(session_id) if session_id
       @resume_session = session_id ? Session.load(session_id) : nil
+      drop_dead_question(@resume_session) if @resume_session
       if @resume_session
         # --model overrides resumed session's model (runtime only, default unchanged)
         if flag_model_name
@@ -186,7 +188,6 @@ module Samagotchi
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
         appended_prompt_files: @appended_prompt_files,
-        recap: scratch ? nil : recap_config,
         scratch: scratch,
         reminders: {
           callback: lambda { |due_names|
@@ -249,7 +250,8 @@ module Samagotchi
     # post-turn conversation.
     # @return [Symbol, nil] :turn_failed when lines came from a pipe and a
     #   turn failed, :empty_answer when a -p --non-interactive turn ended
-    #   with no answer (bin/chi exits 1 on both), :interrupted when Ctrl-C
+    #   with no answer, :iteration_limit when the iteration limit cut that
+    #   turn short (bin/chi exits 1 on all three), :interrupted when Ctrl-C
     #   cancelled that turn (bin/chi exits 130)
     def run
       # --non-interactive with no --prompt is a harmless no-op exit: build
@@ -295,11 +297,11 @@ module Samagotchi
 
       if @prompt && @non_interactive
         # A /cut TEXT / /queue TEXT prompt runs its text as the turn's
-        # prompt, the same as the idle REPL does (Formatting#steer_choice);
+        # prompt, the same as the idle REPL does (ComposerRoute.steer_choice);
         # a bare /cut / /queue (no text) is refused above as a UI command,
         # so only the text here. The images are the text's, not the words'.
         one_shot_prompt =
-          if (choice = steer_choice(@prompt)) && !choice.last.empty?
+          if (choice = ComposerRoute.steer_choice(@prompt)) && !choice.last.empty?
             choice.last
           else
             @prompt
@@ -309,12 +311,13 @@ module Samagotchi
         # Retry lines and hook notices on stderr; stdout gets the answer below.
         sink = OneShotSink.new
         save_before_first_turn(session)
+        max_iterations = IterationLimit.for(no_interrupt: true)
         begin
           result = @engine.run_turn(
             session,
             one_shot_prompt,
             on_event: sink,
-            max_iterations: IterationLimit.for(no_interrupt: true),
+            max_iterations: max_iterations,
             cancel_controller: nil,
             images: ImageInput.extract(one_shot_prompt)
           )
@@ -337,6 +340,11 @@ module Samagotchi
         session.save
         # The after_turn hooks' notices, after the answer as the REPL shows them.
         sink.flush
+        # The limit cut the turn short: what came so far is no answer, so say
+        # so and fail (bin/chi exits 1), as the REPL's "iteration limit
+        # reached" line does there.
+        return one_shot_exhausted(session, max_iterations) if result.resumable?
+
         return
       end
 
@@ -390,6 +398,16 @@ module Samagotchi
       :turn_failed
     end
 
+    # A -p --non-interactive turn the iteration limit cut short: a line on
+    # stderr, with how to go on unless the session goes with this run.
+    # @return [Symbol] :iteration_limit
+    def one_shot_exhausted(session, max_iterations)
+      line = "chi: the iteration limit (#{max_iterations}) was reached before the turn finished"
+      line += "; continue it with: chi --resume #{session.id}" unless @scratch
+      warn line
+      :iteration_limit
+    end
+
     # `chi -p "/models" --non-interactive`: the command's output; a refused
     # one fails the run (bin/chi exits 1). The session is saved only when
     # the command changed it. Nobody is there to answer a confirm: a
@@ -518,6 +536,17 @@ module Samagotchi
       @pending_card_handle = @engine.subscribe(observer: pending)
     end
 
+    # A question the session's last owner saved and died with (a worker's,
+    # or another REPL's): this TUI owns the session now, so nobody waits on
+    # it. Dropped and saved, as the worker does (Worker#drop_dead_question).
+    def drop_dead_question(session)
+      id = session.drop_dead_question
+      return unless id
+
+      Log.info(:repl, "dead_question_dropped", id: id)
+      session.save
+    end
+
     # Take the session's OwnerLock for this process's lifetime: the TUI runs
     # its own Engine, so no worker may run the session meanwhile.
     # @raise [SessionBusy] when a worker or another TUI owns it
@@ -806,34 +835,35 @@ module Samagotchi
       return if input.empty?
 
       # /cut TEXT and /queue TEXT are deliveries only while a turn runs; at
-      # the prompt both run the text as a normal turn, as their usage says.
-      if (choice = steer_choice(input))
-        return @surface.commit(STEER_CHOICE_USAGE) if choice.last.empty?
+      # the prompt both run the text as a normal turn, as their usage says
+      # (the route is the text's).
+      route = ComposerRoute.call(input, running: false, registry: command_registry)
+      return @surface.commit(STEER_CHOICE_USAGE) if route.kind == :usage
 
-        input = choice.last
-      end
+      input = route.text if route.choice
 
       # /model, /models, !rollback, !cmd, /continue (shared with workers);
       # an anytime command's cards print as it shows them (btw's
       # "thinking…" before the answer). Piped input has nobody to answer a
       # confirm (the next line is already written): a costly /thinking or
       # /reasoning-history applies at once.
-      confirm = !piped_input?
-      command = if command_registry.anytime?(input)
-                  @engine.running_anytime { @commands.run(input, confirm: confirm) }
-                else
-                  @commands.run(input, confirm: confirm)
-                end
-      if command
-        show_command_result(command)
-        persist_recent_history(input) if command.shell
-        return
-      end
-      return if show_local_command(input)
-
+      case route.kind
+      when :command
+        confirm = !piped_input?
+        command = if command_registry.anytime?(input)
+                    @engine.running_anytime { @commands.run(input, confirm: confirm) }
+                  else
+                    @commands.run(input, confirm: confirm)
+                  end
+        if command
+          show_command_result(command)
+          persist_recent_history(input) if command.shell
+          return
+        end
+      when :local then return if show_local_command(input)
       # A typo of a command (/modle) is not a prompt: say so, send nothing.
-      hint = command_registry.unknown_command_hint(input)
-      return @surface.commit(hint) if hint
+      when :typo then return @surface.commit(route.reply)
+      end
 
       @turn_flow.before_prompt_turn
       persist_recent_history(input)
@@ -1136,29 +1166,42 @@ module Samagotchi
     #
     # A command that waits for the turn's end (/model X, !cmd) and every line
     # after it wait in @after_turn, in the order typed (D1), with the image
-    # lines (which never steer): once the turn ends they come back after the
-    # steering it didn't merge (typed before them), ahead of anything sent
-    # after Ctrl-C.
+    # lines (which never steer) and /queue's: once the turn ends they come
+    # back with the steering it didn't merge, in the order sent (each line
+    # the turn takes gets the next @input_seq), ahead of anything sent after
+    # Ctrl-C.
     def with_steering(&)
       return yield unless @repl_input
 
       @after_turn = []
       @command_waits = false
-      @repl_input.during_turn(method(:steer_line), leftovers: -> { @pending_input_queue.drain + lines_after_turn }, &)
+      @input_seq = 0
+      @repl_input.during_turn(method(:steer_line), leftovers: -> { leftover_lines }, &)
     end
 
-    # The lines that waited for the turn's end, taken from @after_turn. After
-    # a canceled or failed turn (Ctrl-C raises through here; a failure too)
-    # a !cmd among them is dropped (D4): running it would close the
-    # !rollback the turn left.
+    # The turn's leftovers in send order: steering it didn't merge and the
+    # lines that waited for its end.
+    def leftover_lines
+      (@pending_input_queue.drain_entries + lines_after_turn).sort_by { |seq, _| seq || 0 }.map(&:last)
+    end
+
+    # The next line's place in send order (#leftover_lines).
+    def next_input_seq
+      @input_seq = (@input_seq || 0) + 1
+    end
+
+    # The [seq, line] entries that waited for the turn's end, taken from
+    # @after_turn. After a canceled or failed turn (Ctrl-C raises through
+    # here; a failure too) a !cmd among them is dropped (D4): running it
+    # would close the !rollback the turn left.
     def lines_after_turn
-      lines = @after_turn.slice!(0..)
+      entries = @after_turn.slice!(0..)
       ended = if @active_cancel_controller&.cancelled? || $!.is_a?(Interrupt) then "canceled"
               elsif $! then "failed"
               end
-      return lines unless ended
+      return entries unless ended
 
-      lines.reject do |line|
+      entries.reject do |_seq, line|
         next false unless command_registry.lookup(line)&.id == :shell
 
         @surface.commit("turn #{ended}: #{line.strip} not run; send it again")
@@ -1179,28 +1222,32 @@ module Samagotchi
     # to end and runs as a turn of its own.
     # @return [Boolean, :back] whether the turn took it, :back to put it back
     def steer_line(line)
-      local = local_command(line) unless line.nil?
+      route = ComposerRoute.call(line, running: true, registry: command_registry) unless line.nil?
+      local = route&.local
       return exit_after_turn(delete: SessionCommands.delete_on_exit?(line)) if line.nil? || local == :exit
       return archive_after_turn if local == :archive
       return detach_note if local == :detach
       return false if @active_cancel_controller&.cancelled?
 
-      # Before every command check: /cut and /queue are the UIs' own words
-      # for a delivery (they are listed for Tab and /help, never run).
-      if (choice = steer_choice(line))
-        return submit_steer_choice(*choice)
+      case route.kind
+      # Before every command check (ComposerRoute): /cut and /queue are the
+      # UIs' own words for a delivery (listed for Tab and /help, never run).
+      when :usage
+        @surface.commit(STEER_CHOICE_USAGE)
+        return true
+      when :deliver then return submit_steer_choice(route.delivery, route.text)
+      when :command
+        policy = command_registry.mid_turn(line)
+        return start_anytime_command(line) if policy == :anytime
+        return command_queued(line) if policy == :queue
       end
-
-      policy = command_registry.mid_turn(line)
-      return start_anytime_command(line) if policy == :anytime
-      return command_queued(line) if policy == :queue
       # A command, never steering text.
-      return command_during_turn(line) if local || command_registry.command?(line)
-      return true if line.strip.empty?
+      return command_during_turn(line) if %i[local command].include?(route.kind)
+      return true if route.kind == :empty
 
       # A typo of a command (/modle) is not steering text: say so, take it.
-      if (hint = command_registry.unknown_command_hint(line))
-        @surface.commit(hint)
+      if route.kind == :typo
+        @surface.commit(route.reply)
         return true
       end
       # Steering merges text only: a line with images runs as the next turn.
@@ -1208,7 +1255,7 @@ module Samagotchi
       # Behind a command that waits for the turn's end, a line waits too.
       return wait_for_turn_end(line) if @command_waits
 
-      @pending_input_queue.push(line.strip)
+      @pending_input_queue.push(route.text, seq: next_input_seq)
       @surface.commit(NEXT_STEP_NOTE)
       true
     end
@@ -1217,25 +1264,21 @@ module Samagotchi
     # otherwise read as prompts (SessionCommands registers them for Tab and
     # help only). A cut asks the engine to cut the generation only thinking
     # too long; a queue waits for the turn's end (the REPL's own after-turn
-    # list). Empty text gets the usage line. A line with images never steers
-    # (as a plain one doesn't).
+    # list). A line with images never steers (as a plain one doesn't).
+    # @param delivery [String] Delivery::CUT or Delivery::QUEUE (ComposerRoute)
     # @return [Boolean] whether the turn took it
-    def submit_steer_choice(choice, text)
-      if text.empty?
-        @surface.commit(STEER_CHOICE_USAGE)
-        return true
-      end
+    def submit_steer_choice(delivery, text)
       return image_line_waits(text) if ImageInput.extract(text).any?
 
       # A /queue waits for the turn's end; a /cut behind a command that
       # already waits there goes after it too.
-      if choice == :queue || @command_waits
+      if Delivery.queue?(delivery) || @command_waits
         @surface.commit(COMMAND_QUEUED)
         return wait_for_turn_end(text)
       end
 
       epoch = @engine.input_epoch
-      @pending_input_queue.push(text)
+      @pending_input_queue.push(text, seq: next_input_seq)
       # With no session running the cut is :off; the text still waits for
       # the running turn's next step.
       @surface.commit(steer_cut_note(@engine.cut_for_steer(nil, epoch: epoch), @engine.steer_cut_after))
@@ -1250,7 +1293,7 @@ module Samagotchi
     # +line+ runs once the turn has ended, in the order typed (#with_steering).
     # @return [true] the turn took it
     def wait_for_turn_end(line)
-      @after_turn << line
+      @after_turn << [next_input_seq, line]
       true
     end
 
@@ -1359,14 +1402,6 @@ module Samagotchi
       Log.debug(:repl, "children_counts_failed", error: e.class.name)
     end
 
-    # Resolve the recap config (on by default). Returns false when explicitly
-    # disabled, nil when nothing is configured, or a Hash when enabled so the
-    # Engine can build the detector. Single precedence path via the Config
-    # registry: CLI > ENV (SAMAGOTCHI_RECAP_*) > file (recap:) > default.
-    def recap_config
-      ConfigFile.recap_config
-    end
-
     # Reset the Engine's shared inactivity clock when a prompt opens (a
     # Reline.pre_input_hook) and on each key typed (RelineSeam.key_handler). This is the
     # single seam the Engine-owned idle recap detector reads, so the idle clock

data/lib/samagotchi/tool_activity.rb

@@ -211,14 +211,14 @@ module Samagotchi
     # "stopped" for a
     # task_wait the user's Stop ended (the task itself runs on), for one
     # whose task was stopped (the stop-task button, or the model's task_stop),
-    # and for a command the user's Stop (or a signal to chi) killed or kept
-    # from starting: a cancel, not a failure (its text still starts "Error:"
-    # for the model).
+    # and for a command the user's Stop (or a signal to chi, a session stop)
+    # killed or kept from starting: a cancel, not a failure (its text still
+    # starts "Error:" for the model).
     def tool_activity_status(result, tool_name = nil, command: nil)
       text = result.to_s
-      return "stopped" if [Tools::Execute::NOT_RUN_ON_STOP, Tools::Execute::NOT_RUN_ON_SIGNAL].include?(text)
+      return "stopped" if [Tools::Execute::NOT_RUN_ON_STOP, *Tools::Execute::NOT_RUN.values].include?(text)
       if tool_name == Tools::Execute::NAME &&
-         text.start_with?(Tools::Execute::STOPPED_BY_USER, Tools::Execute::STOPPED_BY_SIGNAL)
+         text.start_with?(Tools::Execute::STOPPED_BY_USER, *Tools::Execute::STOPPED_BY.values)
         return "stopped"
       end
       return "error" if text.start_with?("Error:")

data/lib/samagotchi/tools/delegate.rb

@@ -203,7 +203,9 @@ module Samagotchi
         delivered = SessionManager.deliver_turn(id, prompt: task, client_id: "#{ClientId::DELEGATE_PREFIX}#{parent.id[0, 8]}",
                                                     state_dir: state_dir)
         case delivered[:status]
-        when :accepted then id
+        when :accepted
+          DelegateWait.mark_turn(parent.id, id, follow_up_turn(id, delivered[:ack], 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 :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"
@@ -215,6 +217,31 @@ module Samagotchi
       end
       private_class_method :follow_up
 
+      # 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.
+      # 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:)
+        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
+      rescue ArgumentError
+        nil
+      end
+      private_class_method :follow_up_turn
+
       # The model as typed (spawn_session stores its resolved ref), else the
       # parent's. No existence check here: spawn_session checks the host
       # (check_host!, its UnknownHost comes back as this tool's Error: line)

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -10,9 +10,14 @@ module Samagotchi
     # What a parent was already told about one delegate child: the newest
     # reply it was given (+reply_file+, ReplyWait's cursor) and the child as
     # it was then (+messages+, +question_id+, +last_turn+: ReplyWait's
-    # baseline). nil +messages+ means no baseline.
-    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages) do
-      def self.empty = new(reply_file: nil, last_turn: nil, question_id: nil, messages: nil)
+    # baseline). nil +messages+ means no baseline. +turn+: the enqueued_id
+    # 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).
+    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn) do
+      def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil) = super
+
+      def self.empty = new
 
       # @param baseline [Hash, nil] ReplyWait.baseline_of's
       def with_baseline(baseline)
@@ -93,7 +98,7 @@ module Samagotchi
         return DelegateCursor.empty unless data.is_a?(Hash)
 
         DelegateCursor.new(reply_file: data["reply_file"], last_turn: data["last_turn"],
-                           question_id: data["question_id"], messages: data["messages"])
+                           question_id: data["question_id"], messages: data["messages"], turn: data["turn"])
       end
 
       def path(parent_id, state_dir:)

data/lib/samagotchi/tools/delegate_wait.rb

@@ -72,7 +72,8 @@ module Samagotchi
           started = monotonic
           wait = ReplyWait.call(child_id, state_dir: sd, cursor: cursor.reply_file, timeout: [left, 0].max,
                                           poll_interval: poll_interval, cancelled: cancelled, baseline: baseline,
-                                          owner_grace: owner_grace, interject: others && -> { others.poll })
+                                          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)
             outcomes.concat(relayed_outcomes.delete(key) || [])
@@ -143,7 +144,9 @@ module Samagotchi
       # gave, and the child as that same look loaded it (a fresh load could
       # swallow a turn that ended in between), so a later wait looks for a
       # later turn and a question already reported isn't reported again.
-      # Nothing moves on a timeout or a cancel.
+      # The follow-up's turn (DelegateCursor#turn) is done with once its end
+      # was reported; a question keeps it. Nothing moves on a timeout or a
+      # cancel.
       # @param wait [ReplyWait::Result]
       # @return [DelegateCursor, nil] the new cursor
       def advance(parent_id, child_id, wait, state_dir:)
@@ -151,6 +154,7 @@ module Samagotchi
 
         DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |cursor|
           cursor = cursor.with(reply_file: wait.file) if wait.status == :done
+          cursor = cursor.with(turn: nil) unless wait.status == :waiting_for_answer
           cursor.with_baseline(ReplyWait.baseline_of(wait.session))
         end
       end
@@ -187,20 +191,28 @@ module Samagotchi
 
       # Point the cursor at the newest reply now, so only a later one counts
       # (a follow-up sent to a child that already answered), and take the
-      # child's baseline before the follow-up goes in.
+      # child's baseline before the follow-up goes in. No turn yet
+      # (#mark_turn, once it went in).
       # @param child [Session] the child as loaded before sending
       def mark_seen(parent_id, child, state_dir:)
         newest = ReplyWait.newest_reply(child.id, state_dir: state_dir)
         DelegateCursors.update(parent_id, child.id, state_dir: state_dir) do |cursor|
-          cursor.with(reply_file: newest).with_baseline(ReplyWait.baseline_of(child))
+          cursor.with(reply_file: newest, turn: nil).with_baseline(ReplyWait.baseline_of(child))
         end
       end
 
+      # The follow-up went in: the child's turn it joins, whose reply the
+      # wait takes (DelegateCursor#turn).
+      # @param turn [String, nil]
+      def mark_turn(parent_id, child_id, turn, state_dir:)
+        DelegateCursors.update(parent_id, child_id, state_dir: state_dir) { |cursor| cursor.with(turn: turn) }
+      end
+
       # A new child's baseline: as spawned, before its first turn ran.
       # @param child [Session] the session spawn_session returned
       def mark_started(parent_id, child, state_dir:)
         DelegateCursors.update(parent_id, child.id, state_dir: state_dir) do |cursor|
-          cursor.with_baseline(ReplyWait.baseline_of(child, question_id: nil))
+          cursor.with(turn: nil).with_baseline(ReplyWait.baseline_of(child, question_id: nil))
         end
       end
 

data/lib/samagotchi/tools/execute.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require_relative "../config"
+require_relative "../log"
 require_relative "../paths"
 require_relative "../process_group"
 require_relative "output_guardrails"
@@ -31,6 +32,10 @@ module Samagotchi
       # stopped the turn: its cancel reason is :signal.
       NOT_RUN_ON_SIGNAL = "Error: not run, a signal to chi stopped the turn"
       STOPPED_BY_SIGNAL = "Error: command stopped by a signal to chi"
+      # The same two when a session stop (chi sessions stop, the web's stop,
+      # a parent stopping its delegate) canceled the turn: :session_stopped.
+      NOT_RUN_ON_SESSION_STOP = "Error: not run, the session was stopped"
+      STOPPED_BY_SESSION_STOP = "Error: command stopped as the session was stopped"
       # The first words of a command killed at the limit in kill mode (hooks
       # match on it).
       TIMEOUT_PREFIX = "Error: command timed out after"
@@ -78,7 +83,8 @@ module Samagotchi
       # @param cancelled [#call] true once the user stopped the turn: the
       #   command is killed (or not started) and its output so far returned
       # @param stop_reason [#call] the stop's reason (:signal: a signal to
-      #   chi, which the result then names instead of the user)
+      #   chi, :session_stopped: a session stop, which the result then names
+      #   instead of the user)
       # @param env [Hash, nil] added to the command's environment
       # @param on_timeout [Symbol, String, nil] :task or :kill (ON_TIMEOUT);
       #   nil reads execute.on_timeout
@@ -115,16 +121,18 @@ module Samagotchi
         # a long command, and return whatever it printed before it was killed.
         stopped_result("#{TIMEOUT_PREFIX} #{timeout_sec}s\n#{TIMEOUT_HINT}", e)
       rescue CommandCancelled => e
-        first = signal?(stop_reason) ? STOPPED_BY_SIGNAL : STOPPED_BY_USER
+        first = STOPPED_BY.fetch(stop_reason.call, STOPPED_BY_USER)
         stopped_result("#{first} after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
       rescue StandardError => e
         "Error: #{e.message}"
       end
 
       # What a command the turn's stop kept from starting returns.
-      def self.not_run(stop_reason) = signal?(stop_reason) ? NOT_RUN_ON_SIGNAL : NOT_RUN_ON_STOP
+      def self.not_run(stop_reason) = NOT_RUN.fetch(stop_reason.call, NOT_RUN_ON_STOP)
 
-      def self.signal?(stop_reason) = stop_reason.call == :signal
+      # The texts above by the stop's reason; any other is the user's Stop.
+      NOT_RUN = { signal: NOT_RUN_ON_SIGNAL, session_stopped: NOT_RUN_ON_SESSION_STOP }.freeze
+      STOPPED_BY = { signal: STOPPED_BY_SIGNAL, session_stopped: STOPPED_BY_SESSION_STOP }.freeze
 
       # execute.on_timeout, or the caller's: :task (the default) or :kill.
       def self.on_timeout_mode(value)
@@ -169,10 +177,14 @@ module Samagotchi
         exit_code_path = File.join(dir, TaskRuntime::EXIT_CODE_FILENAME)
         begin
           pid = spawn_logged(command, env: env, cwd: cwd, logs: logs, exit_code_path: exit_code_path)
-        rescue StandardError
+        rescue StandardError => e
+          Log.info(:turn, "execute_spawn_failed", id: id, error: e.class.name)
           FileUtils.rm_rf(dir)
           raise
         end
+        # Never the command line or its output: a command may carry a
+        # secret, and its output is the tool result's.
+        Log.debug(:turn, "execute_started", id: id, pid: pid, timeout_sec: timeout_sec, on_timeout: on_timeout)
         wait_thr = Process.detach(pid)
         # A stop is done once the shell is reaped and nothing holds the logs:
         # a child that ignores TERM keeps them, so the stop goes on to KILL.
@@ -195,6 +207,7 @@ module Samagotchi
                              timeout_sec: timeout_sec, dir: dir, logs: logs, exit_code_path: exit_code_path)
             if text
               handed_over = true
+              Log.info(:turn, "execute_handed_over", id: id, after_sec: timeout_sec)
               raise HandedOver, text
             end
             # Not adopted because it ended meanwhile: finished too.
@@ -205,10 +218,11 @@ module Samagotchi
           status = wait_thr.value
         rescue HandedOver
           raise
-        rescue Exception # rubocop:disable Lint/RescueException -- kill the child, then re-raise
+        rescue Exception => e # rubocop:disable Lint/RescueException -- kill the child, then re-raise
           # An Interrupt (or anything else) mid-wait: the child is in its own
           # process group, so it never saw the SIGINT. Kill it.
           aborted = true
+          Log.info(:turn, "execute_aborted", id: id, error: e.class.name)
           terminate_process_tree(pid, stopped: stopped) if wait_thr.alive?
           raise
         ensure
@@ -230,9 +244,18 @@ module Samagotchi
           end
         end
 
-        raise CommandTimedOut.new(stdout_text, stderr_text) if timed_out
-        raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started) if was_cancelled
+        elapsed_ms = ((monotonic_time - started) * 1000).round
+        if timed_out
+          Log.info(:turn, "execute_timed_out", id: id, after_sec: timeout_sec)
+          raise CommandTimedOut.new(stdout_text, stderr_text)
+        end
+        if was_cancelled
+          Log.info(:turn, "execute_stopped", id: id, ms: elapsed_ms)
+          raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started)
+        end
 
+        Log.debug(:turn, "execute_finished", id: id, exit: status&.exitstatus, ms: elapsed_ms,
+                                             background: held_open || nil)
         [stdout_text, stderr_text, status, held_open]
       end
       private_class_method :run_command
@@ -348,6 +371,8 @@ module Samagotchi
           Thread.current.report_on_exception = false
           code = waiter.value&.exitstatus
           File.write(path, code.to_s) if code && !File.exist?(path) && Dir.exist?(File.dirname(path))
+        rescue StandardError => e
+          Log.debug(:turn, "execute_exit_code_failed", error: e.class.name, msg: e.message)
         end
       end
       private_class_method :write_missing_exit_code

data/lib/samagotchi/turn_checkpoint.rb

@@ -67,6 +67,7 @@ module Samagotchi
       @boundaries = 0
       @written_at = nil
       @started_at = nil
+      @enqueued_id = nil
     end
 
     # A turn begins (before Engine#run_turn and the worker's running save):
@@ -74,14 +75,18 @@ module Samagotchi
     # images, no turn id), marked at iteration 0, so a worker killed before
     # the loop's first boundary leaves the prompt and a mark the next one
     # settles. A continue turn (no prompt) is the history, marked.
+    # Every mark of the turn carries +enqueued_id+ (InterruptedTurn's).
     # @param prompt [String, nil]
-    def begin_turn(prompt: nil)
+    # @param enqueued_id [String, nil] the input the turn runs
+    def begin_turn(prompt: nil, enqueued_id: nil)
       @boundaries = 0
+      @enqueued_id = enqueued_id.to_s.empty? ? nil : enqueued_id.to_s
       @written_at = nil
       @started_at = Time.now.iso8601(3)
       messages = Array(@session.messages).dup
       messages << { role: "user", content: prompt } unless prompt.to_s.empty?
-      @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0) }
+      @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0,
+                                                                                   enqueued_id: @enqueued_id) }
     end
 
     # The turn ended (or never began): the session saves its own messages.
@@ -104,7 +109,8 @@ module Samagotchi
       # One level deep: the loop may edit an entry in place later (a
       # forget stub) while a save on another thread serializes this one.
       messages = conversation.map { |message| message.is_a?(Hash) ? message.dup : message } + merged
-      marker = InterruptedTurn.new(id: turn_id, started_at: @started_at, at: Time.now.iso8601(3), iteration: @boundaries)
+      marker = InterruptedTurn.new(id: turn_id, started_at: @started_at, at: Time.now.iso8601(3), iteration: @boundaries,
+                                   enqueued_id: @enqueued_id)
       @session.turn_checkpoint = { messages: messages, marker: marker }
       return false unless due? || !merged.empty?
 

data/lib/samagotchi/version.rb

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