samagotchi 0.47.0 → 0.49.0

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/engine.rb

@@ -2470,7 +2470,8 @@ module Samagotchi
         model_key: -> { @model_key },
         state_dir: -> { session_state_dir },
         scratch: -> { @scratch },
-        llm_context: -> { @session&.llm_context }
+        llm_context: -> { @session&.llm_context },
+        frontend: -> { interface }
       )
     end
 

data/lib/samagotchi/model_profile.rb

@@ -40,7 +40,7 @@ module Samagotchi
                 :system_prefix, :user_prefix, :assistant_prefix,
                 :model_prefix,
                 :stop_sequences, :tool_decl_format,
-                :image_template
+                :image_template, :image_check_token
 
     def initialize(config)
       @name = config[:name]
@@ -65,10 +65,12 @@ module Samagotchi
       # How the chat template wraps an image's media marker ("%{marker}"),
       # or nil when chi doesn't know it yet (native images are refused).
       @image_template = config[:image_template]
+      # A token the server's chat template must contain for images to be
+      # sent (VisionSupport); defaults to the template's opening token.
+      @image_check_token = config[:image_check_token] || image_open_token
     end
 
-    # The token the image template opens with, e.g. "<|vision_start|>": the
-    # server's chat template must use it too (VisionSupport).
+    # The token the image template opens with, e.g. "<|vision_start|>".
     def image_open_token
       image_template&.split("%{marker}")&.first.to_s
     end
@@ -92,7 +94,12 @@ module Samagotchi
         assistant_prefix: "",
         model_prefix: "",
         stop_sequences: ["<turn|>", "<|tool_response>"],
-        tool_decl_format: :gemma4
+        tool_decl_format: :gemma4,
+        # The bare marker: llama.cpp's mtmd wraps Gemma 4 images in
+        # <|image>…<image|> itself, as its chat path does (V13 spike). The
+        # template writes <|image|> for an image part; Gemma 3's doesn't.
+        image_template: "%{marker}",
+        image_check_token: "<|image|>"
       )
     end
 

data/lib/samagotchi/plugin/context.rb

@@ -25,9 +25,11 @@ module Samagotchi
     # model's memory overlay key (ctx.model, ctx.model_key).
     # +steer+ takes (text, label), +stop_turn+ and +stop_generation+
     # (reason, label), each true when it acted on a running turn.
+    # +frontend+ returns the Engine's interface (:repl, :worker,
+    # :non_interactive), which ctx.frontend names for plugins.
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
                       :ask_model, :model_name, :model_key, :state_dir, :scratch, :llm_context, :steer, :stop_turn, :stop_generation,
-                      keyword_init: true)
+                      :frontend, keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -103,6 +105,16 @@ module Samagotchi
       # Whether the session is a `chi scratch` one (deleted when it ends).
       def scratch? = !!@host.scratch&.call
 
+      # ctx.frontend's values, by the Engine's interface.
+      FRONTENDS = { repl: :repl, non_interactive: :one_shot, worker: :worker }.freeze
+
+      # What runs the session, read now (the host sets it after the plugins
+      # load): :repl (the REPL, -p without --non-interactive), :one_shot
+      # (-p --non-interactive: one turn, then exit) or :worker (a session
+      # worker: the web, an attached TUI). A host without one is :worker.
+      # @return [Symbol]
+      def frontend = FRONTENDS.fetch(@host.frontend&.call, :worker)
+
       # Whether the session is a delegate child (Session#delegate?): a task
       # another session handed over, not the user's own.
       def delegate? = !!saved_session&.delegate?

data/lib/samagotchi/prompt.rb

@@ -59,30 +59,45 @@ module Samagotchi
       [text + prefill_for(messages, profile, prefill), images]
     end
 
-    def self.image_lines(items, profile, images)
-      return "" if items.empty?
+    # A message's image lines: +text+ holds them all in order (what goes
+    # inside the message); +placeholders+ and +markers+ split the lines of
+    # images not sent from the sent ones' media markers, for Gemma's tool
+    # response, whose markers go after the block.
+    ImageLines = Data.define(:lines) do
+      def text = join(lines)
+      def placeholders = join(lines.reject(&:last))
+      def markers = join(lines.select(&:last))
+
+      private
+
+      def join(subset) = subset.empty? ? "" : "\n#{subset.map(&:first).join("\n")}"
+    end
 
+    def self.image_lines(items, profile, images)
       lines = items.each_with_index.map do |item, index|
-        next item.placeholder unless item.sent?
-        next ImageRef.placeholder(item.ref, ImagePlan::CANT_SEE) unless profile.image_template
+        next [item.placeholder, false] unless item.sent?
+        next [ImageRef.placeholder(item.ref, ImagePlan::CANT_SEE), false] unless profile.image_template
 
         images << item.data
-        "[image #{index + 1}: #{ImageRef.name(item.ref)}] " \
-          "#{Kernel.format(profile.image_template, marker: ImagePlan::NATIVE_PLACEHOLDER)}"
+        ["[image #{index + 1}: #{ImageRef.name(item.ref)}] " \
+         "#{Kernel.format(profile.image_template, marker: ImagePlan::NATIVE_PLACEHOLDER)}", true]
       end
-      "\n#{lines.join("\n")}"
+      ImageLines.new(lines: lines)
     end
 
     def self.format_with_turn_markers(messages, profile, suffixes)
       last_user = messages.rindex { |m| m[:role] == "user" } || -1
       parts = messages.each_with_index.map do |m, index|
-        content = prompt_content_for(m, profile) + suffixes[index]
+        lines = suffixes[index]
+        content = prompt_content_for(m, profile) + (m[:role] == "tool_response" ? lines.placeholders : lines.text)
         previous = index.positive? ? messages[index - 1][:role] : nil
         following = messages[index + 1]&.dig(:role)
         case m[:role]
         when "tool_response"
-          # Inside the model's turn; closed when another role follows.
-          tool_response_blocks(content, profile) +
+          # Inside the model's turn; closed when another role follows. Its
+          # sent images go after the blocks, outside the quoted value, as
+          # Gemma's chat template puts them; placeholder lines stay inside.
+          tool_response_blocks(content, profile) + lines.markers +
             (following && following != "tool_response" && following != "model" ? "#{profile.turn_end}\n" : "")
         when "model"
           content = strip_gemma_thought(content) if index < last_user && !content.include?(profile.tool_call_open)
@@ -136,7 +151,7 @@ module Samagotchi
       parts = []
 
       messages.each_with_index do |m, index|
-        content = prompt_content_for(m, profile) + suffixes[index]
+        content = prompt_content_for(m, profile) + suffixes[index].text
         case m[:role]
         when "system"
           parts << "#{profile.system_prefix}#{content}<|im_end|>\n"

data/lib/samagotchi/prompt_literal_guard.rb

@@ -16,7 +16,10 @@ module Samagotchi
       ["[[SAMAGOTCHI_LITERAL_GEMMA_STRING_DELIM]]", '<|"|>'],
       ["[[SAMAGOTCHI_LITERAL_THINK_OPEN]]", "<|think|>"],
       ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_OPEN]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN],
-      ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_CLOSE]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE]
+      ["[[SAMAGOTCHI_LITERAL_THOUGHT_CHANNEL_CLOSE]]", ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_SOFT]]", "<|image|>"],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_START]]", "<|image>"],
+      ["[[SAMAGOTCHI_LITERAL_IMAGE_END]]", "<image|>"]
     ].freeze
 
     QWEN_TOKEN_PAIRS = [

data/lib/samagotchi/send_command.rb

@@ -333,7 +333,12 @@ module Samagotchi
       false
     end
 
-    def continued_words(session) = session.continues ? " (continues #{session.continues[0, 8]})" : ""
+    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

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"
 
@@ -130,6 +136,10 @@ 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,
@@ -258,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}"
@@ -386,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
@@ -453,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