samagotchi 0.53.0 → 0.54.0

data/lib/samagotchi/send_command.rb

@@ -339,7 +339,7 @@ module Samagotchi
                                                                                   thinking: options[:thinking]),
                                                           state_dir: @state_dir)
                   end
-      rescue SessionManager::ContinueRefused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
+      rescue SessionContinue::Refused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
         error_line("chi send: refused: #{e.message}")
         return 1
       rescue StandardError => e

data/lib/samagotchi/session_continue.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "session"
+require_relative "session_setup"
+require_relative "session_inbox"
+require_relative "session_chain"
+require_relative "child_move"
+require_relative "archive_store"
+require_relative "recap_store"
+require_relative "bridge_client"
+require_relative "model_profile"
+require_relative "log"
+require_relative "session_manager"
+
+module Samagotchi
+  # The next link of a session chain (chi send --new --continues, web
+  # Continue →): SessionManager.continue_session runs .run. The archive,
+  # spawn, stop and wake it builds on are SessionManager's.
+  module SessionContinue
+    # A continue that can't happen (#run). reason: :continued
+    # (another session continues it already: +ids+ names it), :open_children
+    # (open children it can't move to the new link: on an older chi's
+    # worker or open in a chi REPL; +ids+ names them) or :folder_gone (its
+    # folder isn't there).
+    class Refused < StandardError
+      attr_reader :session_id, :reason, :ids
+
+      def initialize(session_id, reason, ids: [], detail: nil)
+        @session_id = session_id
+        @reason = reason
+        @ids = ids
+        super(continue_refused_message(detail))
+      end
+
+      private
+
+      def continue_refused_message(detail)
+        short = @session_id[0, 8]
+        case @reason
+        when :continued then "#{short} is continued already, by #{@ids.first[0, 8]}; continue that one (or last:#{short})"
+        when :open_children
+          "#{short} has delegates still open that can't move to the next link: #{detail}; " \
+          "then continue (or wait for them, stop them or archive them)"
+        else "#{short}'s folder #{detail} is gone"
+        end
+      end
+    end
+
+    # How long #run waits for the previous link's worker to write its
+    # recap (IdleRecap's own request timeout).
+    RECAP_WAIT = 30.0
+    # In the previous link's folder: one continue of a session at a time.
+    LOCK = "continue.lock"
+    # How often a last:<id> continue looks again when another continue
+    # moved the chain's end while it waited for the lock.
+    TRIES = 3
+
+    # Start the next link of a chain: a new session that continues
+    # +id_or_ref+ (Session#continues) in its folder, on its model (the name
+    # it was typed as, so an alias holds) and with its own setup (SessionSetup),
+    # starting with a context note from chi: the link and the previous
+    # link's recap (SessionChain.note_text). The previous link is archived
+    # first, with its finished delegates (archive_session's rules: a turn
+    # running, a prompt queued or the step-limit question refuse; an idle
+    # worker is stopped), so a refusal starts nothing. Its open delegates
+    # (running, waiting, live, an unreported reply, at any depth below them)
+    # move to the new link instead (ChildMove): their reports reach it.
+    # Before that its live worker is asked for a recap and given up to
+    # +recap_wait+ seconds to write it.
+    # One continue of a session at a time (a lock in its folder): a double
+    # click finds the first one's link and is refused; a last:<id> one
+    # follows the chain to its new end instead.
+    # @param id_or_ref [String] an id, a prefix, or last:<id> (SessionChain.resolve)
+    # @param prompt [String, nil] its first message (nil: it starts idle)
+    # @param title [String, nil] what the lists show before the first turn;
+    #   by default the prompt, else the previous link's preview
+    # @return [Session] the new link (#model_warning as spawn_session's,
+    #   #moved_children: the delegates it took over)
+    # @raise [ArgumentError] no such session (Session::AmbiguousId for a prefix of several)
+    # @raise [Refused] continued already, delegates open that can't
+    #   move, or its folder is gone
+    # @raise [ArchiveRefused, OwnedByTUI] as archive_session
+    def self.run(id_or_ref, prompt: nil, title: nil, state_dir: nil, recap_wait: RECAP_WAIT, archive_wait: 5)
+      sd = state_dir || Session.default_state_dir
+      TRIES.times do |try|
+        id = SessionChain.resolve(id_or_ref, state_dir: sd)
+        result = with_lock(id, sd) do
+          follow = id_or_ref.to_s.strip.start_with?(SessionChain::LAST_PREFIX) && try < TRIES - 1
+          next :moved if follow && SessionChain.next_of(id, state_dir: sd)
+
+          run_locked(id, prompt: prompt, title: title, state_dir: sd, recap_wait: recap_wait,
+                         archive_wait: archive_wait)
+        end
+        return result unless result == :moved
+      end
+    end
+
+    private_class_method def self.with_lock(id, state_dir, &)
+      dir = Session.session_dir(id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      File.open(File.join(dir, LOCK), File::RDWR | File::CREAT, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        yield
+      end
+    end
+
+    private_class_method def self.run_locked(id, prompt:, title:, state_dir:, recap_wait:, archive_wait:)
+      previous = Session.load(id, state_dir: state_dir)
+      plan = check!(previous, state_dir)
+      # archive_session's refusals that can be known now, before the wait.
+      SessionManager.archivable!(id, state_dir, except: plan.move)
+      recap_before_archive(id, state_dir, wait: recap_wait)
+      # Again: a turn sent to it during the wait may have delegated (they
+      # move too), or a delegate finished.
+      plan = move_plan!(id, state_dir)
+      already = [id, *SessionManager.descendant_ids(id, state_dir, except: plan.move)].select do |sid|
+        ArchiveStore.archived?(Session.session_dir(sid, state_dir: state_dir))
+      end
+      archive = SessionManager.archive_session(id, state_dir: state_dir, wait: archive_wait, except: plan.move)
+      archived = archive[:archived] - already
+      begin
+        spawn_continuation(previous, prompt: prompt, title: title, state_dir: state_dir, move: plan.move)
+      rescue StandardError
+        # Nothing started: the delegates go back, what this archived goes
+        # back to the lists, and a new link saved before its worker failed
+        # to spawn goes (left, it would hold the chain: "continued already",
+        # last: to it).
+        undo_move(id, state_dir, moved: plan.move)
+        begin
+          discard_failed_link(id, state_dir)
+        ensure
+          archived.each { |sid| ArchiveStore.unarchive(sid, state_dir: state_dir) }
+          wake_for_rings(id, state_dir) unless plan.move.empty?
+        end
+        raise
+      end
+    end
+
+    # The delegates a failed #run moved, or began to (its
+    # intent names them), go back to +id+.
+    private_class_method def self.undo_move(id, state_dir, moved:)
+      link = SessionChain.next_of(id, state_dir: state_dir) or return
+      ids = ChildMove.read_intent(link, state_dir: state_dir)&.ids || moved
+      ChildMove.apply(ids, from: link, to: id, state_dir: state_dir, undo: true)
+      ChildMove.clear_intent(link, state_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:worker, "continue_undo_move_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
+    # The link a failed #run saved (no other continues +id+:
+    # check! made sure under the lock): its worker stopped if one
+    # started, then the rings a moved delegate wrote into it just before
+    # the undo go back to +id+, then the link goes. A worker that outlives
+    # the stop is raised (SessionManager::DeleteRefused): the link stays,
+    # and the caller hears it.
+    private_class_method def self.discard_failed_link(id, state_dir)
+      orphan = SessionChain.next_of(id, state_dir: state_dir) or return
+      if SessionManager.refuse_tui!(orphan, state_dir: state_dir) &&
+         !SessionManager.stop_session(orphan, state_dir: state_dir, wait: 10)
+        raise SessionManager::DeleteRefused.new(orphan, :still_stopping)
+      end
+
+      ChildMove.return_rings(from: orphan, to: id, state_dir: state_dir)
+      SessionManager.delete_session(orphan, state_dir: state_dir)
+    rescue SessionManager::DeleteRefused
+      raise
+    rescue StandardError => e
+      Log.warn(:worker, "continue_cleanup_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
+    # A failed continue's previous link, back in the lists, with rings that
+    # came in meanwhile: wake it for them, as the ring's own wake would have.
+    private_class_method def self.wake_for_rings(id, state_dir)
+      return if SessionInbox.find_ring_files(Session.session_dir(id, state_dir: state_dir)).empty?
+
+      SessionManager.wake_for_report(id, state_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:worker, "continue_wake_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
+    # The new link, holding off any worker but its own (ChildMove.starting?)
+    # while +move+ goes to it.
+    private_class_method def self.spawn_continuation(previous, prompt:, title:, state_dir:, move:)
+      recap = RecapStore.read(Session.session_dir(previous.id, state_dir: state_dir))
+      start = prompt.to_s.strip.empty? ? nil : prompt
+      title = previous.first_preview if title.to_s.strip.empty? && start.nil?
+      before_spawn = lambda do |link|
+        ChildMove.mark_starting(link.id, state_dir: state_dir)
+        ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
+      end
+      link = SessionManager.spawn_session(
+        prompt: start, title: title, working_directory: previous.working_directory,
+        model_name: previous.model_typed || previous.model_name, setup: SessionSetup.of(previous),
+        continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
+        note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn
+      )
+      link.moved_children = move
+      link
+    end
+
+    # The refusals that come before anything changes: continued already (no
+    # forks in a chain), an open delegate that can't move to the new link
+    # (ChildMove.plan), the folder gone (the worker would run elsewhere), a
+    # model whose host config.yml no longer has.
+    # @return [ChildMove::Plan]
+    # @raise [Refused, ModelProfile::MissingModel]
+    private_class_method def self.check!(previous, state_dir)
+      if (following = SessionChain.next_of(previous.id, state_dir: state_dir))
+        raise Refused.new(previous.id, :continued, ids: [following])
+      end
+
+      plan = move_plan!(previous.id, state_dir)
+      # Its model's host, as SessionManager.spawn_session checks it: before
+      # the archive stops the previous link's worker.
+      ModelProfile.check_host!(ModelProfile.required_model_name(previous.model_typed || previous.model_name))
+      dir = previous.working_directory.to_s
+      raise Refused.new(previous.id, :folder_gone, detail: dir) unless File.directory?(dir)
+
+      plan
+    end
+
+    # A child still open below a session (#open_children); why: running,
+    # waiting, live, unreported reply, or why it can't move (ChildMove).
+    OpenChild = Data.define(:id, :short_id, :why)
+
+    # The delegates a continue of +id+ moves (ChildMove.plan).
+    # @return [ChildMove::Plan]
+    # @raise [Refused] for open ones it can't move
+    private_class_method def self.move_plan!(id, state_dir)
+      plan = ChildMove.plan(id, open: open_children(id, state_dir), state_dir: state_dir)
+      return plan if plan.refuse.empty?
+
+      raise Refused.new(id, :open_children, ids: plan.refuse.map(&:id),
+                                                    detail: plan.refuse.map { |c| "#{c.short_id} (#{c.why})" }.join(", "))
+    end
+
+    # The unarchived children, at any depth (the archive's cascade), of the
+    # session still running, waiting for an answer, with a live worker, or
+    # (a delegate) with a reply its parent wasn't given (ChildrenStatus).
+    # @return [Array<OpenChild>]
+    def self.open_children(id, state_dir)
+      require_relative "children_status"
+      nodes = [id, *SessionManager.descendant_ids(id, state_dir)]
+      nodes.flat_map { |node| ChildrenStatus.of(node, state_dir: state_dir) }.uniq(&:id).filter_map do |child|
+        why = if %w[waiting running].include?(child.state) then child.state
+              elsif child.live then "live"
+              elsif child.delegate && child.last_reply && !child.reported then "unreported reply"
+              end
+        why && OpenChild.new(id: child.id, short_id: child.short_id, why: why)
+      end
+    end
+
+    # Ask the session's live worker for a recap now (Bridge POST /recap:
+    # IdleRecap#request_now) and wait, up to +wait+ seconds, for recap.json
+    # to change. A worker that is gone wrote its recap when it left; one
+    # that has nothing new to say, too short a conversation, or recaps off
+    # answers at once. Best effort: the continue goes on without.
+    private_class_method def self.recap_before_archive(id, state_dir, wait:)
+      return unless SessionManager.worker_live?(id, state_dir: state_dir)
+
+      dir = Session.session_dir(id, state_dir: state_dir)
+      client = BridgeClient.discover(id, session_dir: dir) or return
+      before = RecapStore.read(dir)
+      reply = client.request_recap
+      asked = reply.status == 200 && reply.json.is_a?(Hash) ? reply.json["request"] : nil
+      return unless %w[started in_flight].include?(asked)
+
+      BridgeClient.poll(wait, interval: 0.2) { RecapStore.read(dir) != before }
+    rescue StandardError => e
+      Log.info(:worker, "continue_recap_failed", sid: id, error: e.class.name, msg: e.message)
+      nil
+    end
+  end
+end

data/lib/samagotchi/session_manager.rb

@@ -65,6 +65,8 @@ module Samagotchi
   autoload :Worker, File.expand_path("worker", __dir__)
   # session_retention requires this file.
   autoload :SessionRetention, File.expand_path("session_retention", __dir__)
+  # session_continue requires this file.
+  autoload :SessionContinue, File.expand_path("session_continue", __dir__)
 
   class SessionManager
     # Raised when the interactive TUI owns the session: it runs its own Engine
@@ -120,35 +122,6 @@ module Samagotchi
       end
     end
 
-    # A continue that can't happen (#continue_session). reason: :continued
-    # (another session continues it already: +ids+ names it), :open_children
-    # (open children it can't move to the new link: on an older chi's
-    # worker or open in a chi REPL; +ids+ names them) or :folder_gone (its
-    # folder isn't there).
-    class ContinueRefused < StandardError
-      attr_reader :session_id, :reason, :ids
-
-      def initialize(session_id, reason, ids: [], detail: nil)
-        @session_id = session_id
-        @reason = reason
-        @ids = ids
-        super(continue_refused_message(detail))
-      end
-
-      private
-
-      def continue_refused_message(detail)
-        short = @session_id[0, 8]
-        case @reason
-        when :continued then "#{short} is continued already, by #{@ids.first[0, 8]}; continue that one (or last:#{short})"
-        when :open_children
-          "#{short} has delegates still open that can't move to the next link: #{detail}; " \
-          "then continue (or wait for them, stop them or archive them)"
-        else "#{short}'s folder #{detail} is gone"
-        end
-      end
-    end
-
     # Spawn a new background session that processes the given prompt (or,
     # with none, waits idle for input).
     #
@@ -168,7 +141,7 @@ module Samagotchi
     # @param setup [SessionSetup] the session's own settings (chi
     #   --llm-context; a fork and a continue copy their session's)
     # @param continues [String, nil] the session this one continues (a
-    #   session field; #continue_session)
+    #   session field; SessionContinue)
     # @param note [String, nil] a context note the session starts with,
     #   from +note_source+: queued before its worker spawns, so its first
     #   turn sees it
@@ -223,227 +196,9 @@ module Samagotchi
       session
     end
 
-    # How long #continue_session waits for the previous link's worker to
-    # write its recap (IdleRecap's own request timeout).
-    CONTINUE_RECAP_WAIT = 30.0
-    # In the previous link's folder: one continue of a session at a time.
-    CONTINUE_LOCK = "continue.lock"
-    # How often a last:<id> continue looks again when another continue
-    # moved the chain's end while it waited for the lock.
-    CONTINUE_TRIES = 3
-
-    # Start the next link of a chain: a new session that continues
-    # +id_or_ref+ (Session#continues) in its folder, on its model (the name
-    # it was typed as, so an alias holds) and with its own setup (SessionSetup),
-    # starting with a context note from chi: the link and the previous
-    # link's recap (SessionChain.note_text). The previous link is archived
-    # first, with its finished delegates (archive_session's rules: a turn
-    # running, a prompt queued or the step-limit question refuse; an idle
-    # worker is stopped), so a refusal starts nothing. Its open delegates
-    # (running, waiting, live, an unreported reply, at any depth below them)
-    # move to the new link instead (ChildMove): their reports reach it.
-    # Before that its live worker is asked for a recap and given up to
-    # +recap_wait+ seconds to write it.
-    # One continue of a session at a time (a lock in its folder): a double
-    # click finds the first one's link and is refused; a last:<id> one
-    # follows the chain to its new end instead.
-    # @param id_or_ref [String] an id, a prefix, or last:<id> (SessionChain.resolve)
-    # @param prompt [String, nil] its first message (nil: it starts idle)
-    # @param title [String, nil] what the lists show before the first turn;
-    #   by default the prompt, else the previous link's preview
-    # @return [Session] the new link (#model_warning as spawn_session's,
-    #   #moved_children: the delegates it took over)
-    # @raise [ArgumentError] no such session (Session::AmbiguousId for a prefix of several)
-    # @raise [ContinueRefused] continued already, delegates open that can't
-    #   move, or its folder is gone
-    # @raise [ArchiveRefused, OwnedByTUI] as archive_session
-    def self.continue_session(id_or_ref, prompt: nil, title: nil, state_dir: nil, recap_wait: CONTINUE_RECAP_WAIT,
-                              archive_wait: 5)
-      sd = state_dir || Session.default_state_dir
-      CONTINUE_TRIES.times do |try|
-        id = SessionChain.resolve(id_or_ref, state_dir: sd)
-        result = with_continue_lock(id, sd) do
-          follow = id_or_ref.to_s.strip.start_with?(SessionChain::LAST_PREFIX) && try < CONTINUE_TRIES - 1
-          next :moved if follow && SessionChain.next_of(id, state_dir: sd)
-
-          continue_locked(id, prompt: prompt, title: title, state_dir: sd, recap_wait: recap_wait,
-                              archive_wait: archive_wait)
-        end
-        return result unless result == :moved
-      end
-    end
-
-    private_class_method def self.with_continue_lock(id, state_dir, &)
-      dir = Session.session_dir(id, state_dir: state_dir)
-      FileUtils.mkdir_p(dir)
-      File.open(File.join(dir, CONTINUE_LOCK), File::RDWR | File::CREAT, 0o600) do |lock|
-        lock.flock(File::LOCK_EX)
-        yield
-      end
-    end
-
-    private_class_method def self.continue_locked(id, prompt:, title:, state_dir:, recap_wait:, archive_wait:)
-      previous = Session.load(id, state_dir: state_dir)
-      plan = check_continue!(previous, state_dir)
-      # archive_session's refusals that can be known now, before the wait.
-      archivable!(id, state_dir, except: plan.move)
-      recap_before_archive(id, state_dir, wait: recap_wait)
-      # Again: a turn sent to it during the wait may have delegated (they
-      # move too), or a delegate finished.
-      plan = move_plan!(id, state_dir)
-      already = [id, *descendant_ids(id, state_dir, except: plan.move)].select do |sid|
-        ArchiveStore.archived?(Session.session_dir(sid, state_dir: state_dir))
-      end
-      archived = archive_session(id, state_dir: state_dir, wait: archive_wait, except: plan.move)[:archived] - already
-      begin
-        spawn_continuation(previous, prompt: prompt, title: title, state_dir: state_dir, move: plan.move)
-      rescue StandardError
-        # Nothing started: the delegates go back, what this archived goes
-        # back to the lists, and a new link saved before its worker failed
-        # to spawn goes (left, it would hold the chain: "continued already",
-        # last: to it).
-        undo_move(id, state_dir, moved: plan.move)
-        begin
-          discard_failed_link(id, state_dir)
-        ensure
-          archived.each { |sid| ArchiveStore.unarchive(sid, state_dir: state_dir) }
-          wake_for_rings(id, state_dir) unless plan.move.empty?
-        end
-        raise
-      end
-    end
-
-    # The delegates a failed #continue_session moved, or began to (its
-    # intent names them), go back to +id+.
-    private_class_method def self.undo_move(id, state_dir, moved:)
-      link = SessionChain.next_of(id, state_dir: state_dir) or return
-      ids = ChildMove.read_intent(link, state_dir: state_dir)&.ids || moved
-      ChildMove.apply(ids, from: link, to: id, state_dir: state_dir, undo: true)
-      ChildMove.clear_intent(link, state_dir: state_dir)
-    rescue StandardError => e
-      Log.warn(:worker, "continue_undo_move_failed", sid: id, error: e.class.name, msg: e.message)
-    end
-
-    # The link a failed #continue_session saved (no other continues +id+:
-    # check_continue! made sure under the lock): its worker stopped if one
-    # started, then the rings a moved delegate wrote into it just before
-    # the undo go back to +id+, then the link goes. A worker that outlives
-    # the stop is raised (DeleteRefused): the link stays, and the caller
-    # hears it.
-    private_class_method def self.discard_failed_link(id, state_dir)
-      orphan = SessionChain.next_of(id, state_dir: state_dir) or return
-      if refuse_tui!(orphan, state_dir: state_dir) && !stop_session(orphan, state_dir: state_dir, wait: 10)
-        raise DeleteRefused.new(orphan, :still_stopping)
-      end
-
-      ChildMove.return_rings(from: orphan, to: id, state_dir: state_dir)
-      delete_session(orphan, state_dir: state_dir)
-    rescue DeleteRefused
-      raise
-    rescue StandardError => e
-      Log.warn(:worker, "continue_cleanup_failed", sid: id, error: e.class.name, msg: e.message)
-    end
-
-    # A failed continue's previous link, back in the lists, with rings that
-    # came in meanwhile: wake it for them, as the ring's own wake would have.
-    private_class_method def self.wake_for_rings(id, state_dir)
-      return if SessionInbox.find_ring_files(Session.session_dir(id, state_dir: state_dir)).empty?
-
-      wake_for_report(id, state_dir: state_dir)
-    rescue StandardError => e
-      Log.warn(:worker, "continue_wake_failed", sid: id, error: e.class.name, msg: e.message)
-    end
-
-    # The new link, holding off any worker but its own (ChildMove.starting?)
-    # while +move+ goes to it.
-    private_class_method def self.spawn_continuation(previous, prompt:, title:, state_dir:, move:)
-      recap = RecapStore.read(Session.session_dir(previous.id, state_dir: state_dir))
-      start = prompt.to_s.strip.empty? ? nil : prompt
-      title = previous.first_preview if title.to_s.strip.empty? && start.nil?
-      before_spawn = lambda do |link|
-        ChildMove.mark_starting(link.id, state_dir: state_dir)
-        ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
-      end
-      link = spawn_session(prompt: start, title: title, working_directory: previous.working_directory,
-                           model_name: previous.model_typed || previous.model_name, setup: SessionSetup.of(previous),
-                           continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
-                           note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn)
-      link.moved_children = move
-      link
-    end
-
-    # The refusals that come before anything changes: continued already (no
-    # forks in a chain), an open delegate that can't move to the new link
-    # (ChildMove.plan), the folder gone (the worker would run elsewhere), a
-    # model whose host config.yml no longer has.
-    # @return [ChildMove::Plan]
-    # @raise [ContinueRefused, ModelProfile::MissingModel]
-    private_class_method def self.check_continue!(previous, state_dir)
-      if (following = SessionChain.next_of(previous.id, state_dir: state_dir))
-        raise ContinueRefused.new(previous.id, :continued, ids: [following])
-      end
-
-      plan = move_plan!(previous.id, state_dir)
-      # Its model's host, as spawn_session checks it: before the archive
-      # stops the previous link's worker.
-      ModelProfile.check_host!(ModelProfile.required_model_name(previous.model_typed || previous.model_name))
-      dir = previous.working_directory.to_s
-      raise ContinueRefused.new(previous.id, :folder_gone, detail: dir) unless File.directory?(dir)
-
-      plan
-    end
-
-    # A child still open below a session (#open_children); why: running,
-    # waiting, live, unreported reply, or why it can't move (ChildMove).
-    OpenChild = Data.define(:id, :short_id, :why)
-
-    # The delegates a continue of +id+ moves (ChildMove.plan).
-    # @return [ChildMove::Plan]
-    # @raise [ContinueRefused] for open ones it can't move
-    private_class_method def self.move_plan!(id, state_dir)
-      plan = ChildMove.plan(id, open: open_children(id, state_dir), state_dir: state_dir)
-      return plan if plan.refuse.empty?
-
-      raise ContinueRefused.new(id, :open_children, ids: plan.refuse.map(&:id),
-                                                    detail: plan.refuse.map { |c| "#{c.short_id} (#{c.why})" }.join(", "))
-    end
-
-    # The unarchived children, at any depth (the archive's cascade), of the
-    # session still running, waiting for an answer, with a live worker, or
-    # (a delegate) with a reply its parent wasn't given (ChildrenStatus).
-    # @return [Array<OpenChild>]
-    def self.open_children(id, state_dir)
-      require_relative "children_status"
-      [id, *descendant_ids(id, state_dir)].flat_map { |node| ChildrenStatus.of(node, state_dir: state_dir) }.uniq(&:id)
-                                          .filter_map do |child|
-        why = if %w[waiting running].include?(child.state) then child.state
-              elsif child.live then "live"
-              elsif child.delegate && child.last_reply && !child.reported then "unreported reply"
-              end
-        why && OpenChild.new(id: child.id, short_id: child.short_id, why: why)
-      end
-    end
-
-    # Ask the session's live worker for a recap now (Bridge POST /recap:
-    # IdleRecap#request_now) and wait, up to +wait+ seconds, for recap.json
-    # to change. A worker that is gone wrote its recap when it left; one
-    # that has nothing new to say, too short a conversation, or recaps off
-    # answers at once. Best effort: the continue goes on without.
-    private_class_method def self.recap_before_archive(id, state_dir, wait:)
-      return unless worker_live?(id, state_dir: state_dir)
-
-      dir = Session.session_dir(id, state_dir: state_dir)
-      client = BridgeClient.discover(id, session_dir: dir) or return
-      before = RecapStore.read(dir)
-      reply = client.request_recap
-      asked = reply.status == 200 && reply.json.is_a?(Hash) ? reply.json["request"] : nil
-      return unless %w[started in_flight].include?(asked)
-
-      BridgeClient.poll(wait, interval: 0.2) { RecapStore.read(dir) != before }
-    rescue StandardError => e
-      Log.info(:worker, "continue_recap_failed", sid: id, error: e.class.name, msg: e.message)
-      nil
-    end
+    # Start the next link of a chain (SessionContinue.run, which has the
+    # rules and raises SessionContinue::Refused).
+    def self.continue_session(...) = SessionContinue.run(...)
 
     # Build the opts hash passed to Process.spawn for a forked worker. The
     # child inherits this process's ENV and reads config.yml itself (as it
@@ -637,10 +392,11 @@ module Samagotchi
     end
 
     # The session and its descendants, with their owners, when they can be
-    # archived now (#archive_refusal for each), else the refusal.
+    # archived now (#archive_refusal for each), else the refusal. Public for
+    # SessionContinue, which checks before its recap wait.
     # @return [Array(Array<String>, Hash)] the ids, and id => OwnerLock::Owner or nil
     # @raise [ArchiveRefused, OwnedByTUI]
-    private_class_method def self.archivable!(id, state_dir, except: [])
+    def self.archivable!(id, state_dir, except: [])
       raise ArchiveRefused.new(id, :scratch) if Session.load(id, state_dir: state_dir).scratch
 
       tree = [id, *descendant_ids(id, state_dir, except: except)]

data/lib/samagotchi/session_metrics.rb

@@ -824,6 +824,8 @@ module Samagotchi
 
         called_as = event.dig(:activity, :called_as)
         active[:called_as] = called_as.to_s if called_as
+        # A grep that found nothing (ok): the reloaded web row says "no match".
+        active[:no_match] = true if event.dig(:activity, :no_match)
         finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i)
       end
     end
@@ -831,7 +833,7 @@ module Samagotchi
     # Caller holds the mutex.
     def finish_tool_record(active, status, waited_ms: 0)
       record = active.slice(
-        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :started_at
+        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :no_match, :started_at
       ).merge(
         status: status,
         completed_at: now.iso8601(3),

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1268,7 +1268,8 @@ module Samagotchi
       # (it ended first).
       def join_tool_line(part, duration_ms: nil)
         output = part[:output]
-        status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool])
+        command = part.dig(:view, :truncated) ? nil : part.dig(:view, :command)
+        status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool], command: command)
         activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
                      params: part[:params], status: status,
                      description: ToolView.description_title(part[:view] || {}) }

data/lib/samagotchi/terminal_ui.rb

@@ -273,6 +273,16 @@ module Samagotchi
       return run_one_shot_command(session) if @prompt && @non_interactive && command_registry.command?(@prompt)
 
       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);
+        # 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?
+            choice.last
+          else
+            @prompt
+          end
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
         # Retry lines and hook notices on stderr; stdout gets the answer below.
@@ -281,11 +291,11 @@ module Samagotchi
         begin
           result = @engine.run_turn(
             session,
-            @prompt,
+            one_shot_prompt,
             on_event: sink,
             max_iterations: IterationLimit.for(no_interrupt: true),
             cancel_controller: nil,
-            images: ImageInput.extract(@prompt)
+            images: ImageInput.extract(one_shot_prompt)
           )
         rescue LLM::ProviderError, ImageStore::Error => e
           return one_shot_failed(session, e)