samagotchi 0.46.1 → 0.48.0

data/lib/samagotchi/child_move.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "atomic_file"
+require_relative "session"
+require_relative "session_inbox"
+require_relative "worker_sidecar"
+require_relative "log"
+require_relative "tools/delegate_cursor"
+
+module Samagotchi
+  # Loaded on first use: session_manager requires terminal_ui, which
+  # requires KernelLoop and so the tools (a require cycle otherwise).
+  autoload :SessionManager, File.expand_path("session_manager", __dir__)
+
+  # A continue moving the previous link's open delegates to the chain's new
+  # link (SessionManager.continue_session), instead of archiving them with
+  # it. A moved child gets a parent override (Session::PARENT_FILE), never a
+  # rewritten session file, so its live worker saving a stale copy changes
+  # nothing; its worker reads the override for its rings and at each turn's
+  # start (Bridge::FEATURES "reparent").
+  #
+  # #apply runs between the new link's save and its worker's spawn, while
+  # the link is #mark_starting (a ring from a moved child must not spawn a
+  # second worker from the child's process until the link's own holds it).
+  # Each step is idempotent,
+  # and an intent file (INTENT_FILE) in the new link's folder names the move
+  # until it is done: a worker that starts and finds one finishes the move
+  # (#adopt), and a failed continue moves the same children back.
+  module ChildMove
+    # <new link dir>/move.json: {from, ids}, while a move is under way.
+    INTENT_FILE = "move.json"
+    # <new link dir>/starting: {pid, at}, from the move to the worker's spawn.
+    STARTING_FILE = "starting"
+    # A starting marker older than this, or whose process is gone, is left
+    # over from a continue that died: it holds nothing back.
+    STARTING_STALE = 60.0
+    # Who the note to a moved child is from (ContextNote's label).
+    NOTE_SOURCE = "session chain"
+    # What a live child's worker must name in its sidecar to be moved.
+    FEATURE = "reparent"
+
+    # What a continue does with the previous link's children: +move+ the
+    # direct children whose subtree has an open node (they go to the new
+    # link, their subtrees with them), +refuse+ the open ones it can't move
+    # (SessionManager::OpenChild, why: an older chi worker or a chi REPL).
+    Plan = Data.define(:move, :refuse)
+    # A move under way: from the session, the children moved.
+    Intent = Data.define(:from, :ids)
+
+    module_function
+
+    # @param open [Array<SessionManager::OpenChild>] the previous link's open
+    #   nodes, at any depth (SessionManager.open_children)
+    # @return [Plan]
+    def plan(prev_id, open:, state_dir:)
+      open_ids = open.map(&:id)
+      move = []
+      refuse = []
+      SessionManager.children_of(prev_id, state_dir: state_dir).each do |row|
+        subtree = [row[:id], *SessionManager.descendant_ids(row[:id], state_dir)]
+        next if (subtree & open_ids).empty?
+
+        if row[:archived]
+          # An open delegate below an archived one: the archive's cascade
+          # would take it, the move doesn't (only unarchived ones move).
+          refuse.concat(open.select { |c| subtree.include?(c.id) }.map do |c|
+            c.with(why: "under archived #{row[:id][0, 8]}; unarchive that one or archive this one")
+          end)
+          next
+        end
+
+        why = unmovable(row[:id], state_dir: state_dir)
+        if why
+          refuse << SessionManager::OpenChild.new(id: row[:id], short_id: row[:id][0, 8], why: why)
+        else
+          move << row[:id]
+        end
+      end
+      Plan.new(move: move, refuse: refuse)
+    end
+
+    # Why a child's live owner keeps it from moving: a chi REPL holds its
+    # own Session and never reads the override; a worker on an older chi
+    # neither. A worker with no sidecar yet is starting, on the newest chi
+    # installed (SessionManager.worker_command): it moves.
+    # @return [String, nil]
+    def unmovable(child_id, state_dir:)
+      owner = SessionManager.session_owner(child_id, state_dir: state_dir) or return nil
+      return "open in a chi REPL; close it there" if owner.tui?
+
+      sidecar = WorkerSidecar.live(Session.session_dir(child_id, state_dir: state_dir), unlink: false)
+      return nil if sidecar.nil? || sidecar.features.include?(FEATURE)
+
+      "older chi worker#{" #{sidecar.version}" if sidecar.version}; restart it"
+    end
+
+    # Move +ids+ (direct children of +from+) to +to+: the intent, the
+    # cursors +to+ lacks (delegates.json), the overrides, the rings waiting
+    # in +from+'s children/, a note to each child, then the intent goes.
+    # Safe to run again on the same move.
+    # @param undo [Boolean] a failed continue moving them back: its note says so
+    def apply(ids, from:, to:, state_dir:, undo: false)
+      return if ids.empty?
+
+      write_intent(to, Intent.new(from: from, ids: ids), state_dir: state_dir)
+      copy_cursors(ids, from: from, to: to, state_dir: state_dir)
+      ids.each { |id| Session.reparent(id, to: to, from: from, state_dir: state_dir) }
+      move_rings(ids, from: from, to: to, state_dir: state_dir)
+      ids.each { |id| note_child(id, to: to, undo: undo, state_dir: state_dir) }
+      clear_intent(to, state_dir: state_dir)
+      Log.info(:worker, undo ? "delegates_moved_back" : "delegates_moved", from: from[0, 8], to: to[0, 8], count: ids.size)
+    end
+
+    # The rings in +from+'s children/ from children whose parent is +to+
+    # now (a failed continue's link, before it is deleted: a child that
+    # read the override just before the undo rang it).
+    def return_rings(from:, to:, state_dir:)
+      ids = SessionInbox.find_ring_files(Session.session_dir(from, state_dir: state_dir)).filter_map do |file|
+        id = SessionInbox.read_ring(file)&.dig(:child_id)
+        id if Session.valid_id?(id) && Session.parent_override(id, state_dir: state_dir) == to
+      end
+      move_rings(ids.uniq, from: from, to: to, state_dir: state_dir)
+    end
+
+    # A worker starting for +session_id+ finishes a move its continue left
+    # half done (the intent file is still there): only those children, never
+    # the predecessor's others.
+    # @return [Array<String>] the ids moved, [] with no intent
+    def adopt(session_id, state_dir:)
+      intent = read_intent(session_id, state_dir: state_dir) or return []
+      apply(intent.ids, from: intent.from, to: session_id, state_dir: state_dir)
+      intent.ids
+    rescue StandardError => e
+      Log.warn(:worker, "delegates_adopt_failed", sid: session_id[0, 8], error: e.class.name, msg: e.message)
+      []
+    end
+
+    # @return [Intent, nil]
+    def read_intent(session_id, state_dir:)
+      data = JSON.parse(File.read(File.join(Session.session_dir(session_id, state_dir: state_dir), INTENT_FILE)))
+      return nil unless data.is_a?(Hash) && Session.valid_id?(data["from"]) && data["ids"].is_a?(Array)
+
+      Intent.new(from: data["from"], ids: data["ids"].select { |id| Session.valid_id?(id) })
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
+    def write_intent(session_id, intent, state_dir:)
+      dir = Session.session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, INTENT_FILE), JSON.generate({ "from" => intent.from, "ids" => intent.ids }))
+    end
+
+    def clear_intent(session_id, state_dir:)
+      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), INTENT_FILE))
+    end
+
+    def copy_cursors(ids, from:, to:, state_dir:)
+      cursors = Tools::DelegateCursors.read(from, state_dir: state_dir).slice(*ids)
+      Tools::DelegateCursors.merge(to, cursors, state_dir: state_dir)
+    end
+
+    # A ring keeps its file name (its time orders the rings).
+    def move_rings(ids, from:, to:, state_dir:)
+      rings = SessionInbox.find_ring_files(Session.session_dir(from, state_dir: state_dir)).select do |file|
+        ids.include?(SessionInbox.read_ring(file)&.dig(:child_id))
+      end
+      return if rings.empty?
+
+      dir = File.join(Session.session_dir(to, state_dir: state_dir), SessionInbox::CHILDREN_DIR)
+      FileUtils.mkdir_p(dir)
+      rings.each do |file|
+        File.rename(file, File.join(dir, File.basename(file)))
+      rescue Errno::ENOENT
+        nil # taken meanwhile
+      end
+    end
+
+    # The child's system prompt names the parent it started with for its
+    # whole life (a prompt-cache miss each time it changed): a note tells a
+    # running one where its notes and reports go now.
+    def note_child(child_id, to:, state_dir:, undo: false)
+      text = if undo
+               "Your parent session is #{to[0, 8]} (#{to}) again: the continue that moved you to its next link " \
+                 "failed. Send notes there, and your reports reach it."
+             else
+               "Your parent session is now #{to[0, 8]} (#{to}), the next link of its session chain: send notes " \
+                 "there, and your reports reach it."
+             end
+      SessionInbox.write_note(child_id, text: text, source: NOTE_SOURCE, state_dir: state_dir)
+    end
+
+    # Hold off a worker for the continue's new link (#starting?) until its
+    # own worker holds it: written before the move, removed by that worker
+    # once it has the owner lock (Worker#start).
+    def mark_starting(session_id, state_dir:)
+      dir = Session.session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, STARTING_FILE), JSON.generate({ "pid" => Process.pid, "at" => Time.now.iso8601(3) }))
+    end
+
+    def clear_starting(session_id, state_dir:)
+      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), STARTING_FILE))
+    end
+
+    # Whether a continue is moving delegates to +session_id+ right now: its
+    # marker is there, fresh, and the process that wrote it runs.
+    def starting?(session_id, state_dir:)
+      file = File.join(Session.session_dir(session_id, state_dir: state_dir), STARTING_FILE)
+      return false unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      return false if Time.now - Time.iso8601(data["at"].to_s) > STARTING_STALE
+
+      process_alive?(data["pid"].to_i)
+    rescue JSON::ParserError, ArgumentError, SystemCallError
+      false
+    end
+
+    # Signal 0 only asks whether the process exists.
+    def process_alive?(pid)
+      return false unless pid.positive?
+
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true
+    end
+  end
+end

data/lib/samagotchi/child_reports.rb

@@ -57,16 +57,21 @@ module Samagotchi
     # @param wake [#call, nil] (parent id) wakes a parent with no worker;
     #   nil: SessionManager.wake_for_report on a thread
     # @return [String, nil] the ring file, nil when none was written
+    # The parent is read fresh: a continue may have moved the child to the
+    # chain's new link (Session::PARENT_FILE) since its worker loaded it.
     def ring(child, why:, state_dir:, wake: nil)
       return nil if mode == "off"
-      return nil unless child&.delegate? && child.parent_id
+      return nil unless child&.delegate?
+
+      parent_id = Session.parent_override(child.id, state_dir: state_dir) || child.parent_id
+      return nil unless parent_id
       # A deleted parent gets no orphan dir.
-      return nil unless Session.exist?(child.parent_id, state_dir: state_dir)
+      return nil unless Session.exist?(parent_id, state_dir: state_dir)
 
-      parent_dir = Session.session_dir(child.parent_id, state_dir: state_dir)
+      parent_dir = Session.session_dir(parent_id, state_dir: state_dir)
       path = SessionInbox.write_ring(parent_dir, child_id: child.id, why: why)
-      Log.info(:worker, "delegate_rang", parent: child.parent_id[0, 8], why: why)
-      wake_parent(child.parent_id, state_dir: state_dir, wake: wake) if mode == "wake"
+      Log.info(:worker, "delegate_rang", parent: parent_id[0, 8], why: why)
+      wake_parent(parent_id, state_dir: state_dir, wake: wake) if mode == "wake"
       path
     rescue StandardError => e
       Log.warn(:worker, "delegate_ring_failed", parent: child&.parent_id.to_s[0, 8], error: e.class.name, msg: e.message)
@@ -129,10 +134,14 @@ module Samagotchi
       def origin = { client_id: "#{ClientId::CHILD_PREFIX}#{child_id[0, 8]}" }
     end
 
-    def initialize(session_id:, state_dir:)
+    # @param predecessor [String, nil] the link this session continues
+    #   (Session#continues): a child a continue moved here may have rung it
+    #   just as it moved (#ring_files)
+    def initialize(session_id:, state_dir:, predecessor: nil)
       @session_id = session_id
       @state_dir = state_dir
       @session_dir = Session.session_dir(session_id, state_dir: state_dir)
+      @predecessor_dir = Session.valid_id?(predecessor) ? Session.session_dir(predecessor, state_dir: state_dir) : nil
       # child id → the Report this turn took for it (rings merged).
       @taken = {}
     end
@@ -142,7 +151,7 @@ module Samagotchi
       return false if ChildRing.mode == "off"
 
       taken = taken_rings
-      SessionInbox.find_ring_files(@session_dir).any? { |file| !taken.include?(file) }
+      ring_files.any? { |file| !taken.include?(file) }
     end
 
     # The reports for rings this turn hasn't taken yet, recorded as taken.
@@ -153,7 +162,7 @@ module Samagotchi
       return [] if ChildRing.mode == "off"
 
       taken = taken_rings
-      fresh = SessionInbox.find_ring_files(@session_dir).reject { |file| taken.include?(file) }
+      fresh = ring_files.reject { |file| taken.include?(file) }
       by_child = fresh.group_by { |file| SessionInbox.read_ring(file)&.dig(:child_id) }
       by_child.filter_map do |child_id, rings|
         report = child_id && report_for(child_id, rings)
@@ -193,6 +202,21 @@ module Samagotchi
       @taken.values.flat_map(&:rings)
     end
 
+    # The rings in children/, and the predecessor's rings from children a
+    # continue moved here (their parent.json names this session): a ring
+    # its child wrote as the move went on. Another child's ring there is
+    # the predecessor's, left alone.
+    def ring_files
+      own = SessionInbox.find_ring_files(@session_dir)
+      return own unless @predecessor_dir
+
+      strays = SessionInbox.find_ring_files(@predecessor_dir).select do |file|
+        child_id = SessionInbox.read_ring(file)&.dig(:child_id)
+        Session.valid_id?(child_id) && Session.parent_override(child_id, state_dir: @state_dir) == @session_id
+      end
+      own + strays
+    end
+
     # A second ring for a child taken earlier in this turn: read from where
     # the first report left the cursor, keeping the first one's +before+.
     def merge_taken(earlier, report)

data/lib/samagotchi/send_command.rb

@@ -4,6 +4,7 @@ require_relative "client_id"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "session_manager"
+require_relative "session_chain"
 require_relative "context_quote"
 require_relative "reply_wait"
 require_relative "parent_report"
@@ -34,6 +35,7 @@ module Samagotchi
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... (ID|PREFIX)...
              chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [-m TEXT] [--image PATH]...
+             chi send --new --continues (ID|PREFIX|last:ID) [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --wait [--timeout S] [--format json] ID
         Sends a message to each session, as if typed in it: a turn starts,
@@ -52,6 +54,14 @@ module Samagotchi
                     web does, and print its id
         --dir DIR   (--new) its folder, the project it belongs to; default
                     the current one
+        --continues ID
+                    (--new) start the next link of that session's chain:
+                    in its folder, on its model and LLM context, with a
+                    note carrying its recap; it is archived. last:ID
+                    names the chain's latest link. Without -m the new
+                    session waits idle. Refused for a session continued
+                    already (naming the next link) or with delegates
+                    still open
         --model M   (--new) its model; default the configured one
         --llm-context LAYERS, --llm-context-apply RULE, --llm-context-budget N
                     (--new) its own LLM context strategy (none, stale,forget),
@@ -83,6 +93,7 @@ module Samagotchi
       f.value "-m", "--message"
       f.switch "--new"
       f.value "--dir"
+      f.value "--continues"
       f.value "--model"
       f.value "--llm-context", key: :llm_strategy
       f.value "--llm-context-apply", key: :llm_apply
@@ -152,10 +163,14 @@ module Samagotchi
       # Before the wait-only case, which would drop the images.
       return usage_error("--image needs a message: pass -m TEXT or pipe it in") if prompt.nil? && !options[:images].empty?
       return run_wait_only(options) if prompt.nil? && options[:wait] && !options[:new]
-      return usage_error("no message: pass -m TEXT or pipe it in") unless prompt
+
+      # The next link of a chain may start idle, waiting for its first message.
+      idle_link = prompt.nil? && options[:continues]
+      return usage_error("--wait needs a message to wait for: pass -m TEXT") if idle_link && options[:wait]
+      return usage_error("no message: pass -m TEXT or pipe it in") unless prompt || idle_link
 
       begin
-        prompt = SessionInbox.checked_text(prompt, noun: "message")
+        prompt &&= SessionInbox.checked_text(prompt, noun: "message")
       rescue SessionInbox::NoteRejected => e
         @stderr.puts("chi send: #{e.message}")
         return 1
@@ -205,7 +220,7 @@ module Samagotchi
       return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
 
-      %i[dir model].each { |key| return usage_error("--#{key} needs --new") if options[key] }
+      %i[dir model continues].each { |key| return usage_error("--#{key} needs --new") if options[key] }
       LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
       return usage_error("give session ids") if options[:ids].empty?
 
@@ -220,6 +235,15 @@ module Samagotchi
     def new_options(options)
       return usage_error("--new takes no session ids: it starts one session") unless options[:ids].empty?
 
+      if options[:continues]
+        taken = [("--dir" if options[:dir]), ("--model" if options[:model])] +
+                LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] }
+        unless taken.compact.empty?
+          return usage_error("--continues takes the previous session's folder, model and LLM context; " \
+                             "leave out #{taken.compact.join(", ")}")
+        end
+      end
+
       words = LLM_CONTEXT_FIELDS.filter_map { |key, field| [field, options[key]] if options[key] }.to_h
       begin
         options[:llm_context] = LLMContextOverride.update(nil, words) unless words.empty?
@@ -253,7 +277,10 @@ module Samagotchi
     # @return [Integer] the exit status
     def run_new(prompt, options)
       images = !@images.empty?
-      if images && (refusal = vision_refusal(options[:model]))
+      model, typed = continued_model(options)
+      return 1 if model == false
+
+      if images && (refusal = vision_refusal(model, typed: typed))
         error_line("chi send: refused: #{refusal}")
         return 1
       end
@@ -264,9 +291,16 @@ module Samagotchi
       through_worker = images || command_like?(prompt)
       begin
         start = through_worker ? { prompt: nil, title: prompt } : { prompt: prompt }
-        session = SessionManager.spawn_session(**start, working_directory: options[:dir],
-                                                        model_name: options[:model], llm_context: options[:llm_context],
-                                                        state_dir: @state_dir)
+        session = if options[:continues]
+                    SessionManager.continue_session(options[:continues], **start, state_dir: @state_dir)
+                  else
+                    SessionManager.spawn_session(**start, working_directory: options[:dir],
+                                                          model_name: options[:model], llm_context: options[:llm_context],
+                                                          state_dir: @state_dir)
+                  end
+      rescue SessionManager::ContinueRefused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
+        error_line("chi send: refused: #{e.message}")
+        return 1
       rescue StandardError => e
         error_line("chi send: could not start a session: #{e.message}")
         return 1
@@ -275,7 +309,7 @@ module Samagotchi
       if through_worker
         return 1 unless deliver_new(session, prompt)
       else
-        @info.puts("#{session.id}  started")
+        @info.puts("#{session.id}  started#{continued_words(session)}")
       end
       @session_id = session.id
       return 0 unless options[:wait]
@@ -285,6 +319,27 @@ module Samagotchi
                                  timeout: options[:timeout])
     end
 
+    # --continues: the model the new link will run (the previous link's),
+    # for the images check; [nil, nil] without --continues.
+    # @return [Array, false] [model_name, model_typed], or false after the
+    #   error line (no such session)
+    def continued_model(options)
+      return [options[:model], nil] unless options[:continues]
+
+      previous = Session.load(SessionChain.resolve(options[:continues], state_dir: @state_dir), state_dir: @state_dir)
+      [previous.model_name, previous.model_typed]
+    rescue ArgumentError => e
+      error_line("chi send: #{e.message}")
+      false
+    end
+
+    def continued_words(session)
+      return "" unless session.continues
+
+      moved = Array(session.moved_children).size
+      " (continues #{session.continues[0, 8]}#{"; #{moved} delegate#{"s" if moved != 1} moved" if moved.positive?})"
+    end
+
     # One existing session, then its next reply. The cursor and baseline
     # are taken before the message goes in, so neither an older reply nor a
     # turn that ends before the first look is mistaken for the answer. A
@@ -371,7 +426,7 @@ module Samagotchi
       end
 
       @sent_command = command_ack?(result[:ack])
-      @info.puts("#{session.id}  started#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
+      @info.puts("#{session.id}  started#{continued_words(session)}#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true
     end
 

data/lib/samagotchi/session.rb

@@ -32,6 +32,12 @@ module Samagotchi
     # resume removes it. A file from before the marker says "stopped" in
     # its status field, which reads the same.
     STOPPED_FILE = "stopped"
+    # A moved session's parent, <session dir>/parent.json ({parent_id, from,
+    # at}): a continue moving a delegate to the chain's new link
+    # (ChildMove) writes it instead of rewriting the session file its live
+    # worker may save a stale copy of; both load paths apply it, like the
+    # stop marker. Never removed: a later move overwrites it.
+    PARENT_FILE = "parent.json"
     # The memory a delegate child starts with (Tools::Delegate::CHILD_MEMORIES).
     DELEGATE_MEMORY = "system/delegated"
 
@@ -72,6 +78,11 @@ module Samagotchi
     # Started by the `delegate` tool (a fork has a parent_id too, but isn't
     # one): see #delegate?.
     attr_writer :delegate
+    # The session this one continues (SessionManager.continue_session): the
+    # previous link of a chain, "the next day of the same routine", else
+    # nil. Not a parent: archiving one link leaves the next alone. The chain
+    # itself is derived (SessionChain), never stored.
+    attr_accessor :continues
     # A `chi scratch` session: deleted when its REPL ends, and by the next
     # sweep (or `chi sessions clean`) when the process died first.
     attr_accessor :scratch
@@ -125,12 +136,17 @@ module Samagotchi
     # not saved.
     attr_accessor :model_warning
 
+    # The delegates a continue moved to this new link (ChildMove;
+    # SessionManager.continue_session sets it); not saved.
+    attr_accessor :moved_children
+
     def initialize(id:, mode:, model_name:, working_directory:, messages:, created_at:, updated_at:,
                    metadata_version: METADATA_VERSION, status: STATUS_IDLE, last_prompt: "",
                    first_preview: "", test_run: false, pending_question: nil,
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
-                   last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [])
+                   last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
+                   continues: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -154,6 +170,7 @@ module Samagotchi
       @scratch = !!scratch
       @last_turn = last_turn
       @delegate = !!delegate
+      @continues = continues&.to_s
       self.llm_context = llm_context
       @archived = false
     end
@@ -205,7 +222,7 @@ module Samagotchi
     #   seed); [] by default
     def self.new_session(mode:, model_name:, working_directory:, test_run: nil,
                          preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, messages: [],
-                         scratch: false, model_typed: nil, delegate: false, llm_context: nil)
+                         scratch: false, model_typed: nil, delegate: false, llm_context: nil, continues: nil)
       now = Time.now.iso8601(3)
       resolved_test = if test_run.nil?
                         test_session_env?
@@ -230,7 +247,8 @@ module Samagotchi
         parent_id: parent_id,
         scratch: scratch,
         delegate: delegate,
-        llm_context: llm_context
+        llm_context: llm_context,
+        continues: continues
       )
     end
 
@@ -250,6 +268,7 @@ module Samagotchi
 
       session = from_h(JSON.parse(File.read(path)))
       session.status = STATUS_STOPPED if stopped_marker?(session.id, state_dir: state_dir)
+      session.parent_id = parent_override(session.id, state_dir: state_dir) || session.parent_id
       session
     rescue JSON::ParserError => e
       raise ArgumentError, "Session file corrupted (#{session_id}): #{e.message}"
@@ -287,7 +306,8 @@ module Samagotchi
       "scratch" => false,
       "last_turn" => nil,
       "delegate" => false,
-      "llm_context" => nil
+      "llm_context" => nil,
+      "continues" => nil
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the
@@ -377,6 +397,7 @@ module Samagotchi
 
       session = from_h(data, messages: false)
       session.status = STATUS_STOPPED if stopped_marker?(session.id, state_dir: File.dirname(path))
+      session.parent_id = parent_override(session.id, state_dir: File.dirname(path)) || session.parent_id
       session
     rescue JSON::ParserError, KeyError, SystemCallError
       nil
@@ -444,6 +465,29 @@ module Samagotchi
       File.exist?(File.join(session_dir(session_id, state_dir: state_dir), STOPPED_FILE))
     end
 
+    # Give +session_id+ a new parent (PARENT_FILE), +from+ the one it had.
+    def self.reparent(session_id, to:, from:, state_dir: default_state_dir)
+      dir = session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      AtomicFile.write(File.join(dir, PARENT_FILE),
+                       JSON.generate({ "parent_id" => check_id!(to), "from" => from, "at" => Time.now.iso8601(3) }))
+    end
+
+    # The parent PARENT_FILE gives the session, nil without one (or with
+    # one that doesn't hold an id).
+    # @return [String, nil]
+    def self.parent_override(session_id, state_dir: default_state_dir)
+      file = File.join(session_dir(session_id, state_dir: state_dir), PARENT_FILE)
+      # The lists read every session: most have none, so no exception each.
+      return nil unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      id = data.is_a?(Hash) && data["parent_id"]
+      valid_id?(id) ? id : nil
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
     # An id that is not a session id: it could name a path outside the
     # sessions dir ("../x", "/etc", "a/b", a NUL), or is empty.
     class InvalidId < ArgumentError; end