samagotchi 0.47.0 → 0.49.0

data/lib/samagotchi/session_manager.rb

@@ -31,6 +31,7 @@ require_relative "image_store"
 require_relative "plugin_session_state"
 require_relative "context_sources"
 require_relative "session_chain"
+require_relative "child_move"
 require_relative "terminal_ui"
 
 module Samagotchi
@@ -118,8 +119,9 @@ module Samagotchi
 
     # A continue that can't happen (#continue_session). reason: :continued
     # (another session continues it already: +ids+ names it), :open_children
-    # (children still running, waiting, live or with a reply it wasn't given:
-    # +ids+ names them) or :folder_gone (its folder isn't there).
+    # (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
 
@@ -137,7 +139,8 @@ module Samagotchi
         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: #{detail}; wait for them, stop them or archive them, then continue"
+          "#{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
@@ -166,12 +169,14 @@ module Samagotchi
     # @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
+    # @param before_spawn [#call, nil] (session) runs once the session and
+    #   its note are saved, before its worker spawns
     # @return [Session] with #seed_images_dropped: refs whose file was gone,
     #   and #model_warning: an id its host's saved list doesn't have
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
                            title: nil, delegate: false, llm_context: nil, continues: nil, note: nil,
-                           note_source: "chi")
+                           note_source: "chi", before_spawn: nil)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
       # alias is retargeted), with the name as typed beside it. A wrong host
@@ -210,6 +215,7 @@ module Samagotchi
       end
       setup_session_directory(session_dir, session, state_dir: sd)
       SessionInbox.write_note(session.id, text: note, source: note_source, state_dir: sd) if note
+      before_spawn&.call(session)
       spawn_worker_for_session(session, state_dir: sd)
       session
     end
@@ -228,10 +234,13 @@ module Samagotchi
     # it was typed as, so an alias holds) and with its own llm_context,
     # 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 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. Before that its live worker is
-    # asked for a recap and given up to +recap_wait+ seconds to write it.
+    # 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.
@@ -239,9 +248,11 @@ module Samagotchi
     # @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)
+    # @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 still open, or its folder is gone
+    # @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)
@@ -270,82 +281,135 @@ module Samagotchi
 
     private_class_method def self.continue_locked(id, prompt:, title:, state_dir:, recap_wait:, archive_wait:)
       previous = Session.load(id, state_dir: state_dir)
-      check_continue!(previous, state_dir)
+      plan = check_continue!(previous, state_dir)
       # archive_session's refusals that can be known now, before the wait.
-      archivable!(id, state_dir)
+      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.
-      check_open_children!(id, state_dir)
-      already = [id, *descendant_ids(id, state_dir)].select do |sid|
+      # 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)[:archived] - already
+      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)
+        spawn_continuation(previous, prompt: prompt, title: title, state_dir: state_dir, move: plan.move)
       rescue StandardError
-        # Nothing started: 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).
-        discard_failed_link(id, state_dir)
-        archived.each { |sid| ArchiveStore.unarchive(sid, state_dir: state_dir) }
+        # 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).
+    # 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
 
-    private_class_method def self.spawn_continuation(previous, prompt:, title:, state_dir:)
+    # 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?
-      spawn_session(prompt: start, title: title, working_directory: previous.working_directory,
-                    model_name: previous.model_typed || previous.model_name, llm_context: previous.llm_context,
-                    continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
-                    note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir)
+      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, llm_context: previous.llm_context,
+                           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), a delegate still open (its report would go to the
-    # archived link), the folder gone (the worker would run elsewhere), a
+    # 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
 
-      check_open_children!(previous.id, state_dir)
+      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 the next link couldn't follow once its parent is archived.
+    # 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)
 
-    # @raise [ContinueRefused] while #open_children has any
-    private_class_method def self.check_open_children!(id, state_dir)
-      open = open_children(id, state_dir)
-      return if open.empty?
+    # 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: open.map(&:id),
-                                                    detail: open.map { |c| "#{c.short_id} (#{c.why})" }.join(", "))
+      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>]
-    private_class_method def self.open_children(id, state_dir)
+    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|
@@ -557,10 +621,12 @@ module Samagotchi
     # @raise [ArchiveRefused] a turn runs in it or in a child, a prompt is
     #   queued in one (a later resume would run it), a live one offers to
     #   continue past the step limit, or it is a scratch session
-    def self.archive_session(id_or_prefix, state_dir: nil, wait: 5)
+    # @param except [Array<String>] descendants left alone with their own
+    #   subtrees (delegates a continue moves to the chain's new link)
+    def self.archive_session(id_or_prefix, state_dir: nil, wait: 5, except: [])
       sd = state_dir || Session.default_state_dir
       id = archive_target(id_or_prefix, sd)
-      tree, owners = archivable!(id, sd)
+      tree, owners = archivable!(id, sd, except: except)
       stopped = tree.select { |sid| owners[sid] }
       stopped.each { |sid| stop_session(sid, state_dir: sd, wait: wait) }
       archived, discarded = tree.partition { |sid| ArchiveStore.archive(sid, state_dir: sd) }
@@ -571,10 +637,10 @@ module Samagotchi
     # archived now (#archive_refusal for each), else the refusal.
     # @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)
+    private_class_method 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)]
+      tree = [id, *descendant_ids(id, state_dir, except: except)]
       owners = tree.to_h { |sid| [sid, session_owner(sid, state_dir: state_dir)] }
       tree.each do |sid|
         refusal = archive_refusal(sid, owners[sid], state_dir)
@@ -620,13 +686,13 @@ module Samagotchi
     end
 
     # Children, their children, …: a delegated session doesn't delegate
-    # further today, a plugin's fork may.
-    private_class_method def self.descendant_ids(id, state_dir)
+    # further today, a plugin's fork may. The walk doesn't enter +except+.
+    def self.descendant_ids(id, state_dir, except: [])
       seen = [id]
       queue = [id]
       until queue.empty?
         children_of(queue.shift, state_dir: state_dir).each do |child|
-          next if seen.include?(child[:id])
+          next if seen.include?(child[:id]) || except.include?(child[:id])
 
           seen << child[:id]
           queue << child[:id]
@@ -695,6 +761,9 @@ module Samagotchi
       # One this process just spawned may not hold the lock yet (a slow
       # start, deliver_turn's second resume): it would only lose it.
       return session if still_starting?(session.id, state_dir: sd)
+      # A continue moving delegates to it spawns its worker once they are
+      # moved; one spawned now (a moved child's ring) would race the move.
+      return session if ChildMove.starting?(session.id, state_dir: sd)
 
       Session.clear_stopped(session.id, state_dir: sd)
       session.status = Session::STATUS_IDLE
@@ -705,18 +774,27 @@ module Samagotchi
 
     # A delegate child rang a parent that has no worker (ChildRing): start
     # one, which runs a turn for the report. Not for a parent that is gone,
-    # stopped, archived, a scratch session, or open in a chi REPL: the ring
-    # waits on disk for whoever runs it next (#resume_session itself would
-    # clear the stop). A stop landing between the check and the resume is
-    # a small window, left as is.
+    # stopped, archived, a scratch session, open in a chi REPL, or a
+    # continue's new link still taking its delegates (its own spawn comes):
+    # the ring waits on disk for whoever runs it next (#resume_session
+    # itself would clear the stop). A stop landing between the check and
+    # the resume is a small window, left as is. An archived parent with a
+    # later link in its chain wakes that link instead: a ring a moved child
+    # wrote just as the continue moved it reaches the new link that way
+    # (ChildReports reads its predecessor's rings).
     # @return [Symbol] :woken, or why not (:gone, :stopped, :archived,
-    #   :scratch, :owned)
-    def self.wake_for_report(session_id, state_dir: nil)
+    #   :scratch, :owned, :starting)
+    def self.wake_for_report(session_id, state_dir: nil, forward: true)
       sd = state_dir || Session.default_state_dir
       return :gone unless Session.exist?(session_id, state_dir: sd)
       return :owned if session_owner(session_id, state_dir: sd)
       return :stopped if Session.stopped_marker?(session_id, state_dir: sd)
-      return :archived if ArchiveStore.archived?(Session.session_dir(session_id, state_dir: sd))
+
+      if ArchiveStore.archived?(Session.session_dir(session_id, state_dir: sd))
+        following = forward && SessionChain.next_of(session_id, state_dir: sd)
+        return following ? wake_for_report(following, state_dir: sd, forward: false) : :archived
+      end
+      return :starting if ChildMove.starting?(session_id, state_dir: sd)
 
       session = Session.load(session_id, state_dir: sd)
       return :stopped if session.status == Session::STATUS_STOPPED

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -2,6 +2,7 @@
 
 require_relative "question_slot"
 require_relative "../turn_flow"
+require_relative "../question_desk"
 
 module Samagotchi
   class TerminalUI
@@ -80,9 +81,15 @@ module Samagotchi
         "  waiting in parent #{@relayed_to} too (answering here works)" if @relayed_to
       end
 
+      # The line a question dismissed in a --non-interactive run leaves (no
+      # one could answer it there): the REPL's own, and an attached UI's on
+      # its cancel (QuestionDesk::UNANSWERABLE_REASON).
+      UNANSWERABLE_TEXT = "(dismissed: no one to answer in a non-interactive run)"
+
       # What a question closed with no answer here says: a relayed approval
       # names where it went; else "(question cancelled)".
       def closed_text(reason)
+        return UNANSWERABLE_TEXT if reason.to_s == QuestionDesk::UNANSWERABLE_REASON
         return CONTINUE_CLOSED.fetch(reason.to_s, "(question cancelled)") if continue?
         return "(question cancelled)" unless @delegate
 

data/lib/samagotchi/terminal_ui.rb

@@ -1356,7 +1356,7 @@ module Samagotchi
     # dismissed it.
     def dismiss_unaskable_question(prompt)
       @engine.cancel_question(QuestionDesk::UNANSWERABLE_REASON) rescue nil
-      banner(prompt.summary("(dismissed: no one to answer in a non-interactive run)", paint: method(:paint)))
+      banner(prompt.summary(QuestionPrompt::UNANSWERABLE_TEXT, paint: method(:paint)))
       false
     end
 

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -33,10 +33,13 @@ module Samagotchi
     # The parent's cursors, one per child, in <parent dir>/delegates.json, so
     # a respawned worker (or a REPL resuming the session) doesn't hand the
     # model a reply it already had. Written by whoever owns the parent (its
-    # worker, or the REPL its kernel runs in), so a Mutex is enough for its
-    # turn thread vs its loop thread; the file is replaced whole.
+    # worker, or the REPL its kernel runs in), and by a continue moving
+    # delegates to the chain's new link (ChildMove, from another process):
+    # a Mutex for the owner's turn thread vs its loop thread, and a flock on
+    # LOCK_FILE between processes; the file is replaced whole.
     module DelegateCursors
       FILE = "delegates.json"
+      LOCK_FILE = "delegates.lock"
       LOCK = Mutex.new
 
       module_function
@@ -51,7 +54,7 @@ module Samagotchi
       # @yieldreturn [DelegateCursor]
       # @return [DelegateCursor] the new cursor
       def update(parent_id, child_id, state_dir:)
-        LOCK.synchronize do
+        locked(parent_id, state_dir: state_dir) do
           all = read(parent_id, state_dir: state_dir)
           cursor = yield get_from(all, child_id)
           all[child_id] = cursor.to_json_hash
@@ -60,6 +63,31 @@ module Samagotchi
         end
       end
 
+      # Add the cursors of +entries+ (child id → cursor fields, as #read
+      # gives them) that the parent has none for; one it has is kept.
+      # @return [Array<String>] the child ids added
+      def merge(parent_id, entries, state_dir:)
+        return [] if entries.empty?
+
+        locked(parent_id, state_dir: state_dir) do
+          all = read(parent_id, state_dir: state_dir)
+          added = entries.keys - all.keys
+          write(parent_id, all.merge(entries.slice(*added)), state_dir: state_dir) unless added.empty?
+          added
+        end
+      end
+
+      def locked(parent_id, state_dir:)
+        LOCK.synchronize do
+          dir = Session.session_dir(parent_id, state_dir: state_dir)
+          FileUtils.mkdir_p(dir)
+          File.open(File.join(dir, LOCK_FILE), File::RDWR | File::CREAT, 0o600) do |lock|
+            lock.flock(File::LOCK_EX)
+            yield
+          end
+        end
+      end
+
       def get_from(all, child_id)
         data = all[child_id]
         return DelegateCursor.empty unless data.is_a?(Hash)

data/lib/samagotchi/tools/task_runtime.rb

@@ -213,7 +213,7 @@ module Samagotchi
         return record unless record["status"] == "running"
 
         pid = record["pid"]
-        return record if chis_group?(record)
+        return record if chis_group?(record, started: record["pid_started"])
         # Gone: its exit code says how it ended.
         return mark_finished_without_exit_code(record) if ProcessGroup.signalable?(pid) && !ProcessGroup.alive?(pid)
 
@@ -222,8 +222,9 @@ module Samagotchi
 
       # Whether the record's pid still leads its own group. With +started+
       # (the start time recorded at task_create), also the same process: a
-      # ps per call, so only task_stop asks it, just before the signal;
-      # a refresh (each task_wait poll, task_list) checks the group only.
+      # ps per call on macOS (~5 ms), asked by each refresh (task_list,
+      # task_get, each task_wait poll) so a reused pid reads as exited, and
+      # by task_stop again just before the signal.
       def chis_group?(record, started: nil) = ProcessGroup.leader?(record["pid"], started: started)
 
       # A running record whose pid isn't a group chi started (NOT_CHIS_PROCESS)

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -73,9 +73,9 @@ module Samagotchi
       return no("the server gives no media marker (update llama.cpp)") unless media_marker(props)
       return no("profile #{profile&.name || "?"} has no image template yet") unless profile&.image_template
 
-      open = profile.image_open_token
-      unless open.empty? || body["chat_template"].to_s.include?(open)
-        return no("the server's chat template doesn't use #{open} (profile #{profile.name})")
+      check = profile.image_check_token
+      unless check.empty? || body["chat_template"].to_s.include?(check)
+        return no("the server's chat template doesn't use #{check} (profile #{profile.name})")
       end
 
       Answer.new(value: true, reason: nil)

data/lib/samagotchi/web/app.rb

@@ -655,9 +655,11 @@ module Samagotchi
         return error if error
 
         port = await_bridge_port(session.id)
-        [session.continues, session.id].each { |sid| @hub&.touch(sid) }
+        moved = session.moved_children || []
+        # The moved delegates' cards fold under the new link now.
+        [session.continues, session.id, *moved].each { |sid| @hub&.touch(sid) }
         record_history(body, prompt) if !idle && PromptHistory.shell_line?(prompt.to_s.strip)
-        json_response(201, session_to_json(session).merge(bridge_port: port))
+        json_response(201, session_to_json(session).merge(bridge_port: port, moved: moved))
       end
 
       # SessionManager.continue_session, its refusals as responses: [session,

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

@@ -37,7 +37,7 @@ import { createTurnView, turnHistoryHtml } from "./turn_view.js";
 import { BADGES, emptyAnswerHtml, htmlElement, stateBadgeHtml, userBubbleHtml } from "./turn_html.js";
 import { createStageView } from "./stage_view.js";
 import { createFamilyPop, familyChipHtml, familyRowsHtml } from "./families_view.js";
-import { CONTINUE_OPENER, allViewChains, chainChipHtml, chainTitle, isOpener, chainDate, chainNeighbours, chainRowsHtml, continueRefusal, foldChains, openChildrenHtml } from "./chains.js";
+import { CONTINUE_OPENER, allViewChains, chainChipHtml, chainTitle, isOpener, chainDate, chainNeighbours, chainRowsHtml, continueRefusal, continuedText, foldChains, openChildrenHtml } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
 import { appendQuote } from "./annotations.js";
 import { parsePresets } from "./annotate_presets.js";
@@ -2265,10 +2265,15 @@ const streamHandlers = {
     if (view.resync) await resync();
     // A card's action that isn't anytime (the step-limit question's
     // /continue) has no bubble: nothing to remove. An anytime or queued
-    // one's bubble was drawn at its command_queued: filled in here.
+    // one's bubble was drawn at its command_queued: filled in here. One
+    // queued for after the turn ran after it: its bubble moves from among
+    // the turn's rows to after its answer and timing line.
     const queued = view.anytime || view.queued ? commandBubble(view.commandId) : null;
     if (view.hidden) queued?.remove();
-    else if (queued) drawCommandBubble(queued, view);
+    else if (queued && view.queued && !view.anytime) {
+      queued.remove();
+      addCommandBubble(view);
+    } else if (queued) drawCommandBubble(queued, view);
     else addCommandBubble(view);
   },
   // An anytime command (/help, a plugin's /btw) runs at once, beside a
@@ -2863,8 +2868,9 @@ $("#infoArchiveBtn").addEventListener("click", () => {
 // Continue → starts the next link of the open session's chain (the server
 // waits up to 30 s for its recap, archives it, starts the new one with the
 // recap as a note) and opens it with the opener in the composer, not sent.
-// A link continued already opens that next link; a refusal for delegates
-// still open names them, each a link.
+// A link continued already opens that next link; its open delegates move
+// to the new link (the toast counts them); a refusal for open delegates
+// that can't move names them, each a link.
 // One continue per session at a time (the server locks it too); another
 // session's continue may run beside it.
 const continuingIds = new Set();
@@ -2881,12 +2887,12 @@ async function continueSelected() {
     addCreatedSession(created);
     const next = created.id;
     if (selected !== id) {
-      showToast(`Continued ${short} in ${next.slice(0, 8)}`, { label: "Open", run: () => select(next) });
+      showToast(continuedText(id, created, { opened: false }), { label: "Open", run: () => select(next) });
       return;
     }
     await select(next);
     if (selected === next) fillOpener();
-    showToast(`Continued ${short} in ${next.slice(0, 8)}; ${short} is archived`);
+    showToast(continuedText(id, created));
   } catch (e) {
     const refusal = continueRefusal(e, allSessions);
     if (refusal.kind === "open") {

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

@@ -201,7 +201,7 @@ export function chainRowsHtml(f, { activeId = null, now = Date.now() } = {}) {
 // What the page does with a refused continue (POST /api/sessions
 // continues, api()'s error with the answer's body): "open" the link that
 // continues it already (409 continued, next_id), "children" naming the
-// delegates still open (409 open_children, ids: {id, short, text} each,
+// delegates still open that can't move (409 open_children, ids: {id, short, text} each,
 // the text its preview and why it is open: the server's word from its
 // detail, "<short> (running)", else its state here), or "error" with the
 // server's words.
@@ -224,11 +224,24 @@ export function continueRefusal(error, sessions = []) {
   return { kind: "error", text };
 }
 
-// The open-children refusal as the toast shows it: the delegates named,
-// each a link to its session.
+// The open-children refusal as the toast shows it: the open delegates the
+// continue can't move to the next link (an older chi's worker, a chi
+// REPL), each a link to its session with what to do about it.
 // @param hrefFor (id) → its page's href
 export function openChildrenHtml(prevId, children, hrefFor) {
   const n = children.length;
   const items = children.map((c) => `<li><a href="${escapeHtml(hrefFor(c.id))}" class="cr-child">${escapeHtml(c.short)}</a>${c.text ? ` ${escapeHtml(c.text)}` : ""}</li>`).join("");
-  return `<div class="continue-refused"><div>Can't continue ${escapeHtml(String(prevId).slice(0, 8))}: ${n} ${n === 1 ? "delegate is" : "delegates are"} still open. Wait for ${n === 1 ? "it" : "them"}, stop or archive ${n === 1 ? "it" : "them"}, then continue.</div><ul>${items}</ul></div>`;
+  return `<div class="continue-refused"><div>Can't continue ${escapeHtml(String(prevId).slice(0, 8))}: ${n} open ${n === 1 ? "delegate" : "delegates"} can't move to the next link. Do what ${n === 1 ? "it says" : "each says"}, or wait for ${n === 1 ? "it" : "them"}, then continue.</div><ul>${items}</ul></div>`;
+}
+
+// The toast after a continue: the new link, the previous one archived (when
+// the page shows the new one), and how many open delegates moved to it
+// (the answer's moved).
+export function continuedText(prevId, created, { opened = true } = {}) {
+  const short = String(prevId).slice(0, 8);
+  const moved = Array.isArray(created?.moved) ? created.moved.length : 0;
+  const parts = [`Continued ${short} in ${String(created?.id || "").slice(0, 8)}`];
+  if (opened) parts.push(`${short} is archived`);
+  if (moved) parts.push(`${moved} open ${moved === 1 ? "delegate" : "delegates"} moved`);
+  return parts.join("; ");
 }

data/lib/samagotchi/worker.rb

@@ -22,6 +22,7 @@ require_relative "iteration_limit"
 require_relative "session_commands"
 require_relative "model_profile"
 require_relative "child_reports"
+require_relative "child_move"
 require_relative "context_absorber"
 require_relative "context_poller"
 require_relative "tools/task_runtime"
@@ -162,6 +163,11 @@ module Samagotchi
     def start
       # The wake turns' budget (delegate reports, attached context), from now.
       @wakes = WorkerWakes.new(grace: WAKE_START_GRACE)
+      # This worker holds the session now (a continue's starting marker held
+      # off any other until it did), and a continue that died moving
+      # delegates here left its intent: finish it.
+      ChildMove.clear_starting(@session_id, state_dir: @state_dir)
+      ChildMove.adopt(@session_id, state_dir: @state_dir)
       @session = Session.load(@session_id, state_dir: @state_dir)
       drop_dead_question
       @engine = build_engine
@@ -195,7 +201,8 @@ module Samagotchi
         ring_question(event) if event[:type] == :question_requested
       })
       # This session's own delegate children's news (rings in children/).
-      @child_reports = ChildReports.new(session_id: @session_id, state_dir: @state_dir)
+      @child_reports = ChildReports.new(session_id: @session_id, state_dir: @state_dir,
+                                        predecessor: @session.continues)
       # Its attached context's notes (ContextSources).
       @context_absorber = ContextAbsorber.new(session_id: @session_id, state_dir: @state_dir,
                                               project_root: @session.project_root)
@@ -802,6 +809,10 @@ module Samagotchi
       restores = @turn_flow.restores
       begin
         @session.status = Session::STATUS_RUNNING
+        # A continue that moved this session to the chain's new link wrote
+        # the new parent beside it (Session::PARENT_FILE): this turn's
+        # status, its rings and every save from here on say so.
+        @session.parent_id = Session.parent_override(@session_id, state_dir: @state_dir) || @session.parent_id
         @session.save(state_dir: @state_dir)
         result = @engine.run_turn(@session, prompt, pending_input: pending_input_drain, **turn_args)
       rescue StandardError => e