samagotchi 0.140.0 → 0.141.0

data/lib/samagotchi/context_sources.rb

@@ -23,13 +23,14 @@ module Samagotchi
   #   sessions/<id>/muted/<name>                   a marker: this session ignores <name>
   #   sessions/<id>/declined/<name>                a marker (its hint inside): the user removed <name>
   #   sessions/<id>/candidates/<name>.json         a Candidate: a source a plugin proposed here (ctx.context.propose)
+  #   sessions/<id>/left.json                      [Left]: what a continue left with the previous link (.move)
   # The guardrails protect the root (ProtectedPaths, CHI_TEXT): a source's
   # command runs later, outside the gate.
   module ContextSources
     DIR = "context"
     NAME_RE = /\A[a-z0-9][a-z0-9-]{0,39}\z/
-    # subscriptions.json shares a session's folder with its sources.
-    RESERVED_NAMES = %w[subscriptions].freeze
+    # subscriptions.json and left.json share a session's folder with its sources.
+    RESERVED_NAMES = %w[subscriptions left].freeze
     SCOPES = %w[session project].freeze
     MIN_EVERY_SECONDS = 30
     DEFAULT_EVERY_SECONDS = 300
@@ -38,6 +39,7 @@ module Samagotchi
     LINE_MAX_CHARS = 300
     SNAPSHOT_SUFFIX = ".snapshot.json"
     SUBSCRIPTIONS_FILE = "subscriptions.json"
+    LEFT_FILE = "left.json"
     MUTED_DIR = "muted"
     DECLINED_DIR = "declined"
     CANDIDATES_DIR = "candidates"
@@ -53,21 +55,32 @@ module Samagotchi
     # folder its cmd's {bundle_dir} names (ContextProviders.command_for).
     # +title+: what a person reads it as (a candidate's, when one was
     # attached; nil for most).
-    Source = Data.define(:name, :cmd, :every_seconds, :why, :hint, :scope, :added_by, :created_at, :provider, :title) do
-      def initialize(name:, cmd:, every_seconds:, why:, hint:, scope:, added_by:, created_at:, provider: nil, title: nil) = super
+    # +movable+: whether a continue or a fork takes it to the new session
+    # (ContextSources.move); nil derives it (#movable?).
+    Source = Data.define(:name, :cmd, :every_seconds, :why, :hint, :scope, :added_by, :created_at, :provider, :title,
+                         :movable) do
+      def initialize(name:, cmd:, every_seconds:, why:, hint:, scope:, added_by:, created_at:, provider: nil, title: nil,
+                     movable: nil) = super
 
       def push? = cmd.nil?
 
+      # Given (+movable+), else derived from who writes the text: a command
+      # source moves (chi runs its command, in the new session too); a
+      # pushed one stays (its writer holds the old session's id).
+      def movable? = movable.nil? ? !push? : movable
+
       def to_h
         { "name" => name, "cmd" => cmd, "every_seconds" => every_seconds, "why" => why, "hint" => hint,
           "scope" => scope, "added_by" => added_by, "created_at" => created_at, "provider" => provider,
-          "title" => title }.compact
+          "title" => title, "movable" => movable }.compact
       end
 
       def self.from_h(data)
+        movable = data["movable"]
         new(name: data["name"].to_s, cmd: data["cmd"], every_seconds: data["every_seconds"]&.to_i,
             why: data["why"], hint: data["hint"], scope: data["scope"].to_s, added_by: data["added_by"],
-            created_at: data["created_at"], provider: data["provider"], title: data["title"])
+            created_at: data["created_at"], provider: data["provider"], title: data["title"],
+            movable: [true, false].include?(movable) ? movable : nil)
       end
     end
 
@@ -179,10 +192,11 @@ module Samagotchi
         return [] unless Dir.exist?(dir)
 
         Dir.children(dir).sort.filter_map do |file|
-          next unless file.end_with?(".json") && !file.end_with?(SNAPSHOT_SUFFIX) && file != SUBSCRIPTIONS_FILE
+          next unless file.end_with?(".json") && !file.end_with?(SNAPSHOT_SUFFIX)
 
           name = file.delete_suffix(".json")
-          name.match?(NAME_RE) ? source(name) : nil
+          # subscriptions.json, left.json: not sources.
+          name.match?(NAME_RE) && !RESERVED_NAMES.include?(name) ? source(name) : nil
         end
       end
 
@@ -374,6 +388,18 @@ module Samagotchi
         AtomicFile.write(File.join(dir, SUBSCRIPTIONS_FILE), JSON.generate(subs.transform_values(&:to_h)))
       end
 
+      # What a continue left with the previous link (ContextSources.move).
+      # @return [Array<Left>] none without the file
+      def left
+        rows = ContextSources.read_json_value(File.join(dir, LEFT_FILE))
+        Array(rows).filter_map { |row| Left.from_h(row) if row.is_a?(Hash) && row["name"].is_a?(String) }
+      end
+
+      def write_left(rows)
+        FileUtils.mkdir_p(dir)
+        AtomicFile.write(File.join(dir, LEFT_FILE), JSON.generate(rows.map(&:to_h)))
+      end
+
       def update_subscription(name)
         subs = subscriptions
         subs[name] = yield(subs[name] || Subscription.blank(name))
@@ -382,8 +408,215 @@ module Samagotchi
       end
     end
 
+    # A source a move left behind (ContextSources.move): its +name+ and
+    # +why+, :pushed (derived: its writer holds the old id) or :not_movable
+    # (its movable: false).
+    Stayed = Data.define(:name, :why) do
+      def label = why == :pushed ? "pushed" : "not movable"
+
+      # The peer whose pairing this is ("Claude"), for a pushed
+      # <peer>-inbox or <peer>-outbox (the peer bundles' names: the move
+      # runs where no plugin is loaded, so the name is all there is; it
+      # only words the note, PeerSources decides what a peer is); nil for
+      # any other.
+      def peer
+        match = why == :pushed && PEER_NAME.match(name)
+        match ? match[1].capitalize : nil
+      end
+
+      def inbox? = name.end_with?("-inbox")
+    end
+    # A source a continue left with the previous link (+from+), as the new
+    # link's left.json keeps it: its +name+ and +hint+, the snapshot's (a
+    # pushed hint: a peer's re-pair pushes its new inbox there) else the
+    # source's. ctx.context.left_behind reads it (Plugin::Peer asks the peer
+    # to pair again at that inbox).
+    Left = Data.define(:name, :hint, :from) do
+      def to_h = { "name" => name, "hint" => hint, "from" => from }.compact
+
+      def self.from_h(data) = new(name: data["name"].to_s, hint: data["hint"]&.to_s, from: data["from"]&.to_s)
+    end
+
+    PEER_NAME = /\A([a-z][a-z0-9]*)-(?:inbox|outbox)\z/
+
+    # What ContextSources.move did: the names it took to the new session
+    # (+moved+) and the sources it left (+stayed+, Stayed).
+    Moved = Data.define(:moved, :stayed) do
+      def self.none = new(moved: [], stayed: [])
+
+      def empty? = moved.empty? && stayed.empty?
+
+      # The new session's note (one sentence each, no instructions); nil
+      # when nothing moved or stayed.
+      # @param from [String] the session the sources came from
+      def note_text(from)
+        return nil if empty?
+
+        lines = []
+        lines << "Context moved with this session: #{moved.join(", ")}." unless moved.empty?
+        lines << "Left with #{from.to_s[0, 8]}: #{left_words.join(", ")}." unless stayed.empty?
+        lines.join(" ")
+      end
+
+      # Each stayed source with why; a peer's pairing as one group, saying
+      # what chi does about it (Plugin::Peer posts the moved message to an
+      # inbox left behind; an outbox alone hears of it on its next push's
+      # refusal), never whether it worked.
+      def left_words
+        stayed.group_by { |s| s.peer || s }.values.map do |group|
+          peer = group.first.peer
+          next "#{group.first.name} (#{group.first.label})" unless peer
+
+          how = if group.any?(&:inbox?)
+                  "#{peer}'s pairing: chi asks #{peer} to pair again with this session"
+                else
+                  "#{peer} pairs again when it next answers"
+                end
+          "#{group.map(&:name).join(", ")} (#{how})"
+        end
+      end
+
+      # A UI's few words (chi send --new --continues); nil for nothing.
+      def words
+        parts = []
+        parts << "context moved: #{moved.join(", ")}" unless moved.empty?
+        parts << "context stayed: #{stayed.map(&:name).join(", ")}" unless stayed.empty?
+        parts.empty? ? nil : parts.join("; ")
+      end
+
+      # chi web's continue answer (moved_context).
+      def to_h = { "moved" => moved, "stayed" => stayed.map { |s| { "name" => s.name, "why" => s.label } } }
+
+      # @param data [Hash, nil] #to_h's; nil (an older chi web): nil
+      def self.from_h(data)
+        return nil unless data.is_a?(Hash)
+
+        stayed = Array(data["stayed"]).filter_map do |row|
+          next unless row.is_a?(Hash)
+
+          Stayed.new(name: row["name"].to_s, why: row["why"] == "pushed" ? :pushed : :not_movable)
+        end
+        new(moved: Array(data["moved"]).map(&:to_s), stayed: stayed)
+      end
+    end
+
     module_function
 
+    # Takes the movable sources of session +from+'s own location
+    # (Source#movable?) to session +to+, the new link of a continue or a
+    # plugin fork (+mode+ :continue or :fork), before +to+'s worker starts:
+    # each one's source and snapshot (a plain read: writes are AtomicFile
+    # renames; never Location#locked, which a fetch holds for its whole
+    # command), every declined/ and muted/ marker (the user's choices),
+    # and a subscription per source moved. A continue's says nothing seen
+    # (the new link's first absorb gives the Attached note) at the
+    # snapshot's serial (an old wake doesn't wake it). A fork's is what
+    # its +seed+ (the fork's messages) last had: the newest note about the
+    # source (its note_id, ContextAbsorber#text_note_id), else as a
+    # continue's. Never candidates/, lock files, or a source +to+ has
+    # already (it wins). A continue's link keeps what stayed in left.json
+    # (Left, Location#left).
+    # @param seed [Array<Hash>] a fork's messages
+    # @return [Moved]
+    def move(from:, to:, mode:, state_dir:, seed: nil)
+      raise ArgumentError, "mode is :continue or :fork, not #{mode.inspect}" unless %i[continue fork].include?(mode)
+
+      source_loc = session_location(from, state_dir: state_dir)
+      target = session_location(to, state_dir: state_dir)
+      return Moved.none unless Dir.exist?(source_loc.dir)
+
+      moved = []
+      stayed = []
+      left = []
+      subs = {}
+      source_loc.sources.each do |source|
+        unless source.movable?
+          stayed << Stayed.new(name: source.name, why: source.movable.nil? ? :pushed : :not_movable)
+          left << Left.new(name: source.name, hint: source_loc.snapshot(source.name).hint || source.hint, from: from)
+          next
+        end
+        next if File.exist?(target.source_path(source.name))
+
+        snapshot = copy_source(source, from: source_loc, to: target) or next
+        subs[source.name] = moved_subscription(source.name, snapshot, mode == :fork ? seed : nil)
+        moved << source.name
+      end
+      [DECLINED_DIR, MUTED_DIR].each { |folder| copy_markers(source_loc.dir, target.dir, folder) }
+      target.write_subscriptions(target.subscriptions.merge(subs)) unless subs.empty?
+      target.write_left(left) if mode == :continue && !left.empty?
+      Moved.new(moved: moved, stayed: stayed)
+    end
+
+    # The source's file and its snapshot's (when it has one), as they are.
+    # @return [Snapshot, nil] the snapshot copied (Snapshot.empty: none);
+    #   nil when the source went meanwhile (nothing copied)
+    def copy_source(source, from:, to:)
+      source_raw = File.read(from.source_path(source.name))
+      snapshot_path = from.snapshot_path(source.name)
+      snapshot_raw = File.file?(snapshot_path) ? File.read(snapshot_path) : nil
+      FileUtils.mkdir_p(to.dir)
+      AtomicFile.write(to.snapshot_path(source.name), snapshot_raw) if snapshot_raw
+      AtomicFile.write(to.source_path(source.name), source_raw)
+      data = snapshot_raw && read_json_text(snapshot_raw)
+      data ? Snapshot.from_h(data) : Snapshot.empty
+    rescue SystemCallError
+      nil
+    end
+
+    def read_json_text(raw)
+      data = JSON.parse(raw)
+      data.is_a?(Hash) ? data : nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    def copy_markers(from_dir, to_dir, folder)
+      source = File.join(from_dir, folder)
+      return unless Dir.exist?(source)
+
+      Dir.children(source).each do |name|
+        next unless name.match?(NAME_RE)
+
+        path = File.join(to_dir, folder, name)
+        next if File.exist?(path)
+
+        FileUtils.mkdir_p(File.dirname(path))
+        AtomicFile.write(path, File.read(File.join(source, name)))
+      rescue SystemCallError
+        next
+      end
+    end
+
+    # A moved source's subscription in the new session (#move).
+    def moved_subscription(name, snapshot, seed)
+      blank = Subscription.blank(name).with(seen_serial: snapshot.serial)
+      held = seed && seed_note(name, seed)
+      return blank unless held
+
+      serial, prefix = held
+      same = snapshot.serial == serial && snapshot.revision.to_s.start_with?(prefix)
+      # A partial revision differs from every full one: an Updated note follows.
+      Subscription.blank(name).with(seen: same ? snapshot.revision : prefix, seen_serial: serial)
+    end
+
+    # The serial and revision prefix of the newest text note about +name+
+    # in +messages+ (ContextAbsorber's note_id, ctx-<name>-<serial>-<rev12>).
+    # @return [Array(Integer, String), nil]
+    def seed_note(name, messages)
+      pattern = /\Actx-#{Regexp.escape(name)}-(\d+)-(\h{12})\z/
+      Array(messages).reverse_each do |message|
+        next unless message.is_a?(Hash)
+
+        context_source = message.key?(:context_source) ? message[:context_source] : message["context_source"]
+        next unless context_source == name
+
+        note_id = (message.key?(:note_id) ? message[:note_id] : message["note_id"]).to_s
+        match = pattern.match(note_id) or next
+        return [match[1].to_i, match[2]]
+      end
+      nil
+    end
+
     # <state dir>/context; +state_dir+ is the sessions dir (Session.default_state_dir).
     def root(state_dir: nil)
       File.join(File.dirname(state_dir || Session.default_state_dir), DIR)
@@ -523,10 +756,15 @@ module Samagotchi
     end
 
     def read_json(path)
+      data = read_json_value(path)
+      data.is_a?(Hash) ? data : nil
+    end
+
+    # The JSON value in +path+; nil when there is none or it isn't JSON.
+    def read_json_value(path)
       return nil unless File.file?(path)
 
-      data = JSON.parse(File.read(path))
-      data.is_a?(Hash) ? data : nil
+      JSON.parse(File.read(path))
     rescue JSON::ParserError, SystemCallError
       nil
     end

data/lib/samagotchi/plugin/attached_context.rb

@@ -31,12 +31,15 @@ module Samagotchi
       # session (its name, or its URL) isn't attached again (#declined?)
       # until the user adds it again, or +force+: the user's own explicit
       # choice (a click), which clears the declined marker (by the name,
-      # and by the URL).
+      # and by the URL). +movable+: whether a continue or a fork takes it
+      # to the new session (nil: the default, a command source moves;
+      # ContextSources::Source#movable?).
       # @return [String, nil] the source's name; nil when declined
       # @raise [Error]
-      def attach(url: nil, name: nil, cmd: nil, why: nil, hint: nil, every_seconds: nil, force: false)
+      def attach(url: nil, name: nil, cmd: nil, why: nil, hint: nil, every_seconds: nil, force: false, movable: nil)
         own = own_location!
         source = url ? from_url(url, name: name, why: why) : from_cmd(name: name, cmd: cmd, why: why, hint: hint, every_seconds: every_seconds)
+        source = source.with(movable: movable ? true : false) unless movable.nil?
         if force
           own.undecline(source.name, hint: url && source.hint)
         elsif own.declined?(source.name) || (url && own.declined_hints.include?(source.hint))
@@ -117,6 +120,15 @@ module Samagotchi
         location&.candidates || []
       end
 
+      # What the continue that started this session left with the previous
+      # link (pushed sources, a peer's pairing among them): each one's name,
+      # hint (its last pushed one, else the source's) and the session it
+      # stayed in. Read-only; none for a session that isn't a continue's.
+      # @return [Array<ContextSources::Left>]
+      def left_behind
+        location&.left || []
+      end
+
       # Takes back this session's candidate +name+. A source attached from
       # it stays attached (chi context rm removes that).
       # @return [Boolean] whether there was one

data/lib/samagotchi/plugin/context.rb

@@ -271,6 +271,11 @@ module Samagotchi
       # one its participants read, not the owner's working session.
       def review? = !!saved_session&.review?
 
+      # The id of the session this one continues (a continue's new link,
+      # Session#continues), else nil.
+      # @return [String, nil]
+      def continues = saved_session&.continues
+
       # Whether the session is a fork (ctx.sessions.fork: /btw keep, a
       # plugin's): it has a parent and isn't a delegate child, and it
       # started from a conversation, so its first prompt isn't its first

data/lib/samagotchi/plugin/peer.rb

@@ -40,6 +40,12 @@ module Samagotchi
     # quote. Such a text is titled by its first quoted line, not the quote's
     # `From your thinking:` label.
     #
+    # A continue leaves the pairing with the previous link (its inbox and
+    # outbox are pushed sources: ContextSources.move). The new link's quiet
+    # init task (#pair_again) posts the `moved` message to the inbox left
+    # behind, once, so the peer pairs again with the new id; its chi-peer
+    # skill knows how it paired.
+    #
     # A subclass (the bundle's Plugin) sets the strings, as constants:
     # INBOX, OUTBOX ("<peer>-inbox", "-outbox"), BUNDLE, NAME (the peer, as
     # the model and user call it: "Claude"), APP (its product: "Claude
@@ -62,6 +68,8 @@ module Samagotchi
       PAIR_PLACEHOLDER = "__CHI_PEER_PAIR__"
       PAYLOADS_PLACEHOLDER = "__CHI_PEER_PAYLOADS__"
       DIFF_LINES = 20
+      # Under the session's data dir: the moved message went (or was tried).
+      MOVED_MARKER = "moved-posted"
       # The label line a web quote starts with (annotations.js sourceLabel).
       QUOTE_LABEL = /\AFrom (?:your thinking|your earlier step|the .+ call|my earlier message):\z/
 
@@ -90,6 +98,7 @@ module Samagotchi
           run_command(args.to_s.strip, ctx)
         end
         chi.annotation "Confirm with #{peer::NAME}", command: "#{peer::COMMAND} validate"
+        chi.init("Asking #{peer::NAME} to pair again", quiet: true) { |ctx| pair_again(ctx) }
         # The outbox source is the peer's answers: its own wake budget and
         # line (context.peer_turns).
         chi.peer_source peer::OUTBOX, label: peer::NAME
@@ -130,8 +139,52 @@ module Samagotchi
         "sent to #{self.class::NAME}: #{kind} · #{title}#{" (the text in #{where})" unless where == "inline"}"
       end
 
+      # A continue's new link whose previous link kept this peer's INBOX
+      # (ctx.context.left_behind): posts the moved message to that inbox's
+      # hint, once (a marker under the session's data dir: a worker restart
+      # doesn't post again). A post that fails is logged and dropped: no
+      # retry, and the peer's next push to the old id is refused with the
+      # new one (its skill pairs again then).
+      # @return [String] what it did (the quiet init task's summary)
+      def pair_again(ctx)
+        peer = self.class
+        previous = ctx.continues or return "not a continue"
+        id = ctx.session_id or return "no session yet"
+        left = ctx.context.left_behind.find { |row| row.name == peer::INBOX }
+        hint = left&.hint.to_s.strip
+        return "no #{peer::INBOX} left behind" if hint.empty?
+        return "asked already" unless claim_moved(ctx, id)
+
+        check_hint!(hint)
+        post(hint, moved_message(previous, id))
+        "asked #{peer::NAME} to pair again with #{id[0, 8]}"
+      rescue SendError, SystemCallError, ArgumentError => e
+        ctx.log.warn("moved_not_posted", error: e.message)
+        "couldn't ask #{peer::NAME} to pair again: #{e.message}"
+      end
+
+      # What the peer gets when +previous+ was continued as +id+: the usual
+      # header, kind moved, and how to go on. Not a literal pair command:
+      # the skill knows how its peer paired (a remote, an ssh socket).
+      def moved_message(previous, id)
+        short = previous.to_s[0, 8]
+        "chi #{short} · moved · continued as #{id}\n" \
+          "This chi session was continued as #{id}. Pair with #{id} the way you paired with #{short}, then " \
+          "answer there (chi context push #{self.class::OUTBOX} #{id})."
+      end
+
       private
 
+      # Takes the moved marker for session +id+; false when it is there.
+      def claim_moved(ctx, id)
+        File.open(File.join(session_dir(ctx, id), MOVED_MARKER), File::WRONLY | File::CREAT | File::EXCL, 0o600) do |file|
+          file.write("#{Time.now.utc.iso8601}\n")
+        end
+        true
+      rescue Errno::EEXIST
+        false
+      end
+
       # The transport: sends +text+ to the peer at +hint+ (the inbox's hint).
       # @raise [SendError]
       def post(_hint, _text) = raise(NotImplementedError, "#{self.class} must define #post")

data/lib/samagotchi/plugin/sessions.rb

@@ -7,6 +7,7 @@ require_relative "../worker_link"
 require_relative "../bridge/turn_accumulator"
 require_relative "../tools/delegate"
 require_relative "../children_status"
+require_relative "../context_move"
 require_relative "../review_start"
 require_relative "../model_profile"
 
@@ -42,7 +43,8 @@ module Samagotchi
       # runs it as its first turn, and counts against session.max_children.
       # It keeps this session's own setup (SessionSetup: its llm_context values).
       # Each image a message names is copied into the child, or dropped with
-      # a note in its message when its file is gone.
+      # a note in its message when its file is gone. This session's movable
+      # attached context goes too (ContextMove), with a note naming it.
       # @param messages [Array<Hash>] the child's conversation to start with
       # @param title [String, nil] what the lists show for it (the prompt, or
       #   the first user message, by default)
@@ -60,11 +62,16 @@ module Samagotchi
         prompt = prompt.to_s.strip.empty? ? nil : prompt.to_s
         check_children(parent_id, state_dir) if prompt
 
+        # The fork takes this session's movable attached context, its
+        # subscriptions as its seed last had them.
+        before_spawn = lambda do |forked|
+          ContextMove.call(from: parent_id, to: forked.id, mode: :fork, seed: forked.messages, state_dir: state_dir)
+        end
         child = SessionManager.spawn_session(
           prompt: prompt, working_directory: @host.cwd.call || Dir.pwd, model_name: @host.model_name&.call,
           parent_id: parent_id, messages: Array(messages).map { |message| unfrozen(message) }, preview: title,
           images_from: Session.session_dir(parent_id, state_dir: state_dir), state_dir: state_dir,
-          setup: @host.setup&.call || SessionSetup.new
+          setup: @host.setup&.call || SessionSetup.new, before_spawn: before_spawn
         )
         child.id
       rescue *REFUSED => e

data/lib/samagotchi/send_command.rb

@@ -571,7 +571,9 @@ module Samagotchi
       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?})"
+      context = session.moved_context&.words
+      " (continues #{session.continues[0, 8]}#{"; #{moved} delegate#{"s" if moved != 1} moved" if moved.positive?}" \
+        "#{"; #{context}" if context})"
     end
 
     # One existing session, then its next reply. The cursor and baseline

data/lib/samagotchi/session.rb

@@ -347,6 +347,10 @@ module Samagotchi
     # SessionManager.continue_session sets it); not saved.
     attr_accessor :moved_children
 
+    # The attached context a continue took to this new link
+    # (ContextSources::Moved; SessionContinue sets it); not saved.
+    attr_accessor :moved_context
+
     # The text web `continue →` prefills in this new link
     # (SessionChain.opener_for; SessionManager.continue_session sets it); not
     # saved.

data/lib/samagotchi/session_access/contract.rb

@@ -78,6 +78,8 @@ module Samagotchi
         "context add --every" => SUPPORTED,
         "context add --why" => SUPPORTED,
         "context add --hint" => SUPPORTED,
+        "context add --movable" => SUPPORTED,
+        "context add --no-movable" => SUPPORTED,
         "context add --project" => LOCAL_ONLY,
         "context push" => SUPPORTED,
         "context push --message" => SUPPORTED,

data/lib/samagotchi/session_access/local.rb

@@ -12,6 +12,8 @@ require_relative "../note_delivery"
 require_relative "../image_store"
 require_relative "../context_candidates"
 require_relative "../context_sources"
+require_relative "../archive_store"
+require_relative "../session_chain"
 require_relative "../send_command/busy"
 require_relative "../chi_invocation"
 require_relative "../worker_sidecar"
@@ -285,17 +287,26 @@ module Samagotchi
       # project's when session_id is nil).
 
       # Attaches +source+ to the target's own sources.
+      # @return [ContextAdded]
       def context_add(target, source)
         location = context_location(target)
         location.add(source.with(scope: location.scope))
-        nil
+        ContextAdded.new(name: source.name)
       end
 
-      # New text for the target's --push source +name+.
+      # New text for the target's --push source +name+. Refused, nothing
+      # written, when the session was continued (its writer holds a stale
+      # id): a source of its own, or none of the name. A project's source
+      # takes it (the next link sees it too).
       # @param fetched [ContextSources::Fetched]
       # @return [ContextPush]
       def context_push(target, name, fetched)
-        attached = context_attached(target, name) or return ContextPush.new(status: :missing)
+        attached = context_attached(target, name)
+        if !target.project? && (attached.nil? || attached.location.session?) &&
+           (next_id = continued_as(target.session_id))
+          return ContextPush.new(status: :continued, next_id: next_id)
+        end
+        return ContextPush.new(status: :missing) unless attached
         return ContextPush.new(status: :not_push) unless attached.source.push?
 
         before, written = attached.location.locked(name) do
@@ -491,6 +502,16 @@ module Samagotchi
       end
 
       def dir = @state_dir ? { state_dir: @state_dir } : {}
+
+      # The session that continues +id+, or nil. The archive check first: a
+      # continued link is always archived, and SessionChain.next_of loads
+      # every session.
+      def continued_as(id)
+        return nil unless ArchiveStore.archived?(session_dir(id))
+
+        SessionChain.next_of(id, state_dir: state_dir!)
+      end
+
       def state_dir! = @state_dir || Session.default_state_dir
       def session_dir(id) = Session.session_dir(id, state_dir: state_dir!)
 

data/lib/samagotchi/session_access/remote.rb

@@ -181,7 +181,8 @@ module Samagotchi
         json = reply.json
         Created.new(id: json.fetch("id"), model_warning: json["model_warning"], continues: json["continues"],
                     moved_children: json["moved"] || [], parent_answers_warning: json["parent_answers_warning"],
-                    first_turn_id: json["first_turn_id"])
+                    first_turn_id: json["first_turn_id"],
+                    moved_context: ContextSources::Moved.from_h(json["moved_context"]))
       end
 
       # Whether a just-created session's worker came up within +timeout+
@@ -458,21 +459,23 @@ module Samagotchi
 
       # --- context (a session's own sources: a project's are local only)
 
+      # @return [ContextAdded]
       # @raise [ContextSources::Invalid] refused (a name taken, a bad one)
       def context_add(target, source)
-        body = { name: source.name, why: source.why, hint: source.hint, added_by: source.added_by }
+        body = { name: source.name, why: source.why, hint: source.hint, added_by: source.added_by, movable: source.movable }
         source.push? ? body[:push] = true : body.merge!(cmd: source.cmd, every: source.every_seconds)
-        context_added(request(:post, "#{session_path(target.session_id)}/context", body: body.compact))
-        nil
+        reply = request(:post, "#{session_path(target.session_id)}/context", body: body.compact)
+        context_added(reply)
+        ContextAdded.new(name: source.name, movable_dropped: movable_dropped?(reply, source.movable))
       end
 
       # A URL through the remote's installed bundles' providers (chi web's
       # {url} body: the page's own).
-      # @return [String] the source's name
+      # @return [ContextAdded] the source's name
       # @raise [ContextProviders::Invalid] no bundle there resolves it
-      def context_add_url(target, url, why:, hint:, added_by:)
+      def context_add_url(target, url, why:, hint:, added_by:, movable: nil)
         reply = request(:post, "#{session_path(target.session_id)}/context",
-                        body: { url: url, why: why, hint: hint, added_by: added_by }.compact)
+                        body: { url: url, why: why, hint: hint, added_by: added_by, movable: movable }.compact)
         if reply.status == 422 && no_provider?(reply)
           require_relative "../context_providers"
           detail = "no installed bundle on #{name} resolves #{url} (chi bundle install github-pr there for GitHub PRs)"
@@ -482,9 +485,13 @@ module Samagotchi
           raise ContextProviders::Invalid, "#{reply.json["detail"]} (on #{name})"
         end
         context_added(reply)
-        reply.json.fetch("name")
+        ContextAdded.new(name: reply.json.fetch("name"), movable_dropped: movable_dropped?(reply, movable))
       end
 
+      # A movable flag sent that the 201 doesn't echo: an older chi web
+      # dropped it.
+      def movable_dropped?(reply, movable) = !movable.nil? && !reply.json.key?("movable")
+
       # @param fetched [ContextSources::Fetched]
       # @return [ContextPush]
       def context_push(target, name, fetched)
@@ -498,6 +505,10 @@ module Samagotchi
 
           raise_refusal(reply)
         when 409 then ContextPush.new(status: :not_push)
+        when 410
+          raise_refusal(reply) unless reply.error == "context_continued"
+
+          ContextPush.new(status: :continued, next_id: reply.json["next_id"].to_s)
         when 400 then raise ContextSources::Invalid, reply.json["detail"].to_s
         else raise_refusal(reply)
         end