samagotchi 0.160.0 → 0.161.0

data/lib/samagotchi/session_retention.rb

@@ -4,6 +4,8 @@ require "fileutils"
 require "time"
 require_relative "session"
 require_relative "archive_store"
+require_relative "worker_presence"
+require_relative "starting_marker"
 require_relative "config"
 require_relative "log"
 require_relative "model_profile"
@@ -18,8 +20,8 @@ module Samagotchi
   # (session.retention_days), count (session.max_count, counting only the
   # sessions that stay), statuses kept (session.keep_status), sessions left
   # empty (SessionManager.discardable?, an hour on), leftover scratch
-  # sessions (once past SCRATCH_START_GRACE) and skeleton-only directories; a session with a live owner
-  # always stays.
+  # sessions and skeleton-only directories; a session with a live owner, or
+  # whose worker is being started (StartingMarker), always stays.
   module SessionRetention
     # The session.retention_days / max_count / keep_status defaults.
     DEFAULT_RETENTION_DAYS = 14
@@ -53,13 +55,19 @@ module Samagotchi
         dry_run: dry_run,
         test_only: test_only,
         any_age: any_age,
-        alive_check: ->(sid) { !SessionManager.session_owner(sid, state_dir: sd).nil? },
+        alive_check: ->(sid) { owned?(sid, sd) },
         empty_check: discard ? ->(sid) { left_empty?(sid, state_dir: sd, default_model: default_model) } : nil
       )
       result[:deleted].concat(prune_orphan_dirs(sd, dry_run: dry_run)) if discard && !test_only
       result
     end
 
+    # Someone holds the session's owner lock (a worker, a one-turn run).
+    private_class_method def self.owned?(session_id, state_dir)
+      WorkerPresence.read(session_id, state_dir: state_dir,
+                                      owner: SessionManager.session_owner(session_id, state_dir: state_dir)).owned?
+    end
+
     private_class_method def self.left_empty?(session_id, state_dir:, default_model:)
       path = Session.session_file(session_id, state_dir: state_dir)
       Time.now - File.mtime(path) > EMPTY_GRACE_SECONDS &&
@@ -80,7 +88,7 @@ module Samagotchi
         next unless Session.valid_id?(name) && File.directory?(dir)
         next if File.exist?(File.join(state_dir, "#{name}#{SessionPaths::FILE_EXT}"))
         next unless Time.now - File.mtime(dir) > EMPTY_GRACE_SECONDS && SessionManager.empty_session_dir?(dir)
-        next if SessionManager.session_owner(name, state_dir: state_dir)
+        next if owned?(name, state_dir) || starting?(name, state_dir)
 
         unless dry_run
           FileUtils.rm_rf(dir)
@@ -93,14 +101,18 @@ module Samagotchi
       end
     end
 
-    # How long after its save an unowned scratch session may still be
-    # waiting for the worker just spawned for it to take its owner lock.
-    SCRATCH_START_GRACE = SessionManager::WORKER_START_GRACE
+    # A worker is being started for it (every spawn marks it, a new
+    # session's before its file is saved): no owner yet doesn't mean nobody
+    # runs it.
+    private_class_method def self.starting?(session_id, state_dir)
+      StartingMarker.fresh?(session_id, state_dir: state_dir)
+    end
 
-    private_class_method def self.scratch_starting?(path, now)
-      now - File.mtime(path) < SCRATCH_START_GRACE
-    rescue SystemCallError
-      false
+    # Being started or owned now (+alive_check+, when given, reads the owner).
+    private_class_method def self.held?(session_id, state_dir, alive_check)
+      starting?(session_id, state_dir) || alive_check&.call(session_id) == true
+    rescue StandardError
+      true
     end
 
     # Lazy sweep guard: runs prune at most once per SWEEP_INTERVAL_HOURS
@@ -172,9 +184,11 @@ module Samagotchi
     # count (`chi sessions clean` with no --days: test runs are throwaway).
     #
     # A scratch session nobody owns (its terminal and worker were killed) goes whatever its
-    # age, its status and the count; +test_only+ takes it too. One saved
-    # within SCRATCH_START_GRACE (its file's mtime, against +now+) stays: its
-    # worker may not have taken the owner lock yet.
+    # age, its status and the count; +test_only+ takes it too.
+    #
+    # A session whose worker is being started (StartingMarker, fresh) stays,
+    # whatever it is, and takes no count slot: its worker may not have taken
+    # the owner lock yet.
     #
     # +max_count+ counts the sessions that stay: one deleted whatever its
     # place (scratch, left empty, expired, +any_age+) takes no slot.
@@ -186,6 +200,9 @@ module Samagotchi
     def self.apply(state_dir: Session.default_state_dir, days: DEFAULT_RETENTION_DAYS, max_count: DEFAULT_MAX_COUNT,
                    keep_status: DEFAULT_KEEP_STATUS, dry_run: false, test_only: false, alive_check: nil,
                    empty_check: nil, any_age: false, now: Time.now)
+      require_relative "schedules"
+      schedules = Schedules.new(state_dir: state_dir)
+      scheduled_targets = schedules.protected_session_ids
       keep_status = Array(keep_status).map(&:to_s)
       # Fetch all sessions sorted newest-first for count logic
       all = Session.list(state_dir: state_dir, sort: "updated_at", order: "desc")
@@ -200,6 +217,7 @@ module Samagotchi
       deleted = []
       kept = []
       skipped = []
+      purge_ids = []
       passed_over = 0
 
       all.each_with_index do |session, idx|
@@ -210,6 +228,11 @@ module Samagotchi
           next
         end
 
+        if scheduled_targets.include?(session.id)
+          kept << session.id
+          next
+        end
+
         # Protected by keep_status
         if keep_status.include?(session.status.to_s) && !session.scratch
           kept << session.id
@@ -228,10 +251,9 @@ module Samagotchi
           end
         end
 
-        # A scratch session saved within SCRATCH_START_GRACE: `chi scratch`
-        # saves it, then spawns the worker that takes its owner lock, so no
-        # owner yet doesn't mean a leftover. Kept, it takes no count slot.
-        if session.scratch && scratch_starting?(path, now)
+        # Being started (a resume, a new or scratch session): its worker
+        # takes the owner lock in a moment. Kept, it takes no count slot.
+        if starting?(session.id, state_dir)
           kept << session.id
           passed_over += 1
           next
@@ -277,20 +299,28 @@ module Samagotchi
         # Eligible for deletion
         if dry_run
           deleted << session.id
+        # Looked at again right before its files go (the list was read
+        # once, at the start): resumed or taken by a worker since, it stays.
+        elsif held?(session.id, state_dir, alive_check)
+          kept << session.id
+        elsif scheduled_targets.include?(session.id)
+          kept << session.id
         else
           begin
-            FileUtils.rm_f(path)
-            sidecar = File.join(state_dir, session.id)
-            FileUtils.rm_rf(sidecar)
-            PluginSessionState.remove(session.id)
-            ContextSources.remove_session(session.id, state_dir: state_dir)
+            # Under the owner lock, the start read again (as a delete).
+            SessionManager.remove_files(session.id, path, File.join(state_dir, session.id), state_dir: state_dir,
+                                        purge_runs: false)
             deleted << session.id
+            purge_ids << session.id
+          rescue SessionManager::DeleteRefused
+            kept << session.id
           rescue StandardError
             skipped << session.id
           end
         end
       end
 
+      SessionManager.purge_removal_stores(purge_ids, state_dir: state_dir)
       { deleted: deleted, kept: kept, skipped: skipped }
     end
   end

data/lib/samagotchi/session_setup.rb

@@ -24,20 +24,27 @@ module Samagotchi
   # +parent_answers+ the session's own guardrails.parent_answers (a level
   # String, tighten-only: Guardrails::ParentPolicy.effective) or nil,
   # +working_set_pins+ the items the user pinned in the working set
-  # (WorkingSetPin; [] with none).
+  # (WorkingSetPin; [] with none), +preloaded_memory_names+ and
+  # +muted_memory_names+ the names --memory and --mute selected ([] with
+  # none). A delegate source's reserved memory is not copied to a normal
+  # child, and a fork cannot inherit it because its parent_id would mark it
+  # as a delegate.
   #
   # It doesn't save itself: the session keeps each setting in its own field
   # and file key, and resolves it on its own. A delegate child starts
   # without one (but the toolkit its delegate call named, and its parent's
   # parent_answers); a continue and a fork copy their session's (.of).
-  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files, :toolkit,
-                             :toolkit_origin, :settings, :parent_answers, :working_set_pins) do
+  SessionSetup = Data.define(:llm_context, :thinking, :reasoning_history, :appended_prompt_files,
+                             :preloaded_memory_names, :muted_memory_names, :toolkit, :toolkit_origin, :settings,
+                             :parent_answers, :working_set_pins) do
     def initialize(llm_context: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [], toolkit: nil,
-                   toolkit_origin: nil, settings: nil, parent_answers: nil, working_set_pins: [])
+                   preloaded_memory_names: [], muted_memory_names: [], toolkit_origin: nil, settings: nil,
+                   parent_answers: nil, working_set_pins: [])
       toolkit_origin ||= "chosen" if toolkit
       super(llm_context: llm_context, thinking: thinking, reasoning_history: reasoning_history,
             appended_prompt_files: Array(appended_prompt_files).map(&:to_s).freeze, toolkit: toolkit,
-            toolkit_origin: toolkit_origin&.to_s,
+            preloaded_memory_names: name_list(preloaded_memory_names),
+            muted_memory_names: name_list(muted_memory_names), toolkit_origin: toolkit_origin&.to_s,
             settings: SessionConfig::Settings.of(settings), parent_answers: parent_answers&.to_s,
             working_set_pins: WorkingSetPin.list(working_set_pins))
     end
@@ -51,12 +58,25 @@ module Samagotchi
     # always: one from before toolkits is full (Toolkit.of), not whatever
     # config's default is now.
     # @param session [Session, nil]
+    # @param forked [Boolean] whether the new session is a forked child
     # @return [SessionSetup]
-    def self.of(session)
+    def self.of(session, forked: false)
       return new if session.nil?
 
-      new(**members.to_h { |member| [member, self::CARRY.fetch(member) { ->(s) { s.public_send(member) } }.call(session)] })
+      values = members.to_h do |member|
+        [member, self::CARRY.fetch(member) { ->(s) { s.public_send(member) } }.call(session)]
+      end
+      if forked || session.delegate?
+        values[:preloaded_memory_names] = values[:preloaded_memory_names].reject do |name|
+          name == Session::DELEGATE_MEMORY
+        end
+      end
+      new(**values)
     end
+
+    private
+
+    def name_list(names) = Array(names).map { |name| name.to_s.strip }.reject(&:empty?).uniq.freeze
   end
 
   # How SessionSetup.of carries a member that isn't its session's field as

data/lib/samagotchi/starting_marker.rb

@@ -2,51 +2,120 @@
 
 require "fileutils"
 require "json"
+require "securerandom"
 require "time"
 require_relative "atomic_file"
 require_relative "session"
 
 module Samagotchi
-  # A continue's "starting" marker on its new link: written before the
-  # continue moves delegates there (ChildMove) and spawns the link's worker,
-  # removed by that worker once it holds the owner lock (Worker#start). While
-  # it is #fresh?, nothing else spawns a worker for the link (SpawnPart's
-  # resume_session and wake_for_report): a ring from a moved child must not
-  # start a second one. CROSS-VERSION: the file name and its {pid, at} are
-  # read and cleared by other chi versions (spec/worker_contract_spec.rb).
+  # A session's "starting" marker: a worker is being started for it. Every
+  # spawn writes it (SpawnPart's spawn_worker_for_session: the writer's pid
+  # before the spawn, the starter's after; a continue's before it moves
+  # delegates to its new link), and the worker removes it once it holds the
+  # owner lock (Worker#start). While it is #fresh?, nothing else spawns a
+  # worker for the session (WorkerPresence#starting?). CROSS-VERSION: the
+  # file name and its {pid, at} are read and cleared by other chi versions
+  # (spec/worker_contract_spec.rb).
   module StartingMarker
-    # <new link dir>/starting: {pid, at}, from the move to the worker's spawn.
+    # <session dir>/starting: {pid, at}, from the decision to spawn to the
+    # worker holding the lock.
     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.
+    # over from a start that died: it holds nothing back.
     STALE = 60.0
 
     module_function
 
-    # Hold off a worker for the continue's new link (#fresh?) until its
-    # own worker holds it: written before the move, removed by that worker
-    # once it has the owner lock (Worker#start).
-    def mark(session_id, state_dir:)
+    # Hold off any other worker for +session_id+ (#fresh?) until the one
+    # being started holds it, for as long as +pid+ runs: removed by that
+    # worker once it has the owner lock (Worker#start).
+    # @param pid [Integer] the process the hold lasts for: the writer, or
+    #   the worker's starter once it is spawned
+    def mark(session_id, state_dir:, pid: Process.pid)
       dir = Session.session_dir(session_id, state_dir: state_dir)
       FileUtils.mkdir_p(dir)
-      AtomicFile.write(File.join(dir, FILE), JSON.generate({ "pid" => Process.pid, "at" => Time.now.iso8601(3) }))
+      AtomicFile.write(File.join(dir, FILE), JSON.generate({ "pid" => pid, "at" => Time.now.iso8601(6) }))
     end
 
-    def clear(session_id, state_dir:)
-      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), FILE))
+    # Claim the start of +session_id+'s worker: write the marker only when
+    # no fresh one holds it (a link(2) of a written temp file: of starters
+    # racing, one wins). A stale or dead one is taken over (renamed away,
+    # then checked to be the one judged, so a takeover never removes a new
+    # claim), and so is a fresh one written before +over_before+ (a stop
+    # cancels the starts before it, not the ones after it).
+    # @param pid [Integer] the process the hold lasts for (#mark)
+    # @param over_before [Time, nil] take over a start marked at or before it
+    # @return [Boolean] whether this caller holds the start now
+    def claim(session_id, state_dir:, pid: Process.pid, over_before: nil)
+      dir = Session.session_dir(session_id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      path = File.join(dir, FILE)
+      temp = File.join(dir, "#{FILE}.#{Process.pid}.#{SecureRandom.hex(4)}")
+      File.write(temp, JSON.generate({ "pid" => pid, "at" => Time.now.iso8601(6) }))
+      3.times do
+        File.link(temp, path)
+        return true
+      rescue Errno::EEXIST
+        seen = read_raw(path) or next
+        return false if holds?(seen, over_before)
+        return false unless take_over(path, seen)
+      end
+      false
+    ensure
+      FileUtils.rm_f(temp) if temp
     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 fresh?(session_id, state_dir:)
-      file = File.join(Session.session_dir(session_id, state_dir: state_dir), FILE)
-      return false unless File.exist?(file)
+    # Move the marker +seen+ out of the way: false when what was renamed is
+    # another claim's (put back), true when it was +seen+ or already gone.
+    def take_over(path, seen)
+      tomb = "#{path}.old.#{Process.pid}.#{SecureRandom.hex(4)}"
+      File.rename(path, tomb)
+      return true if File.read(tomb) == seen
+
+      begin
+        File.link(tomb, path)
+      rescue Errno::EEXIST
+        nil
+      end
+      false
+    rescue Errno::ENOENT
+      true
+    ensure
+      FileUtils.rm_f(tomb) if tomb
+    end
+    private_class_method :take_over
 
-      data = JSON.parse(File.read(file))
-      return false if Time.now - Time.iso8601(data["at"].to_s) > STALE
+    def read_raw(path)
+      File.read(path)
+    rescue Errno::ENOENT
+      nil
+    end
+    private_class_method :read_raw
+
+    # Whether the marker text +raw+ holds a start: fresh, its process
+    # running, and (with +over_before+) marked after it.
+    def holds?(raw, over_before = nil)
+      data = JSON.parse(raw)
+      at = Time.iso8601(data["at"].to_s)
+      return false if Time.now - at > STALE
+      return false if over_before && at <= over_before
 
       process_alive?(data["pid"].to_i)
-    rescue JSON::ParserError, ArgumentError, SystemCallError
+    rescue JSON::ParserError, ArgumentError, TypeError, RangeError, SystemCallError
+      false
+    end
+    private_class_method :holds?
+
+    def clear(session_id, state_dir:)
+      FileUtils.rm_f(File.join(Session.session_dir(session_id, state_dir: state_dir), FILE))
+    end
+
+    # Whether a worker is being started for +session_id+ right now: its
+    # marker is there, fresh, and the process it names runs.
+    def fresh?(session_id, state_dir:)
+      raw = read_raw(File.join(Session.session_dir(session_id, state_dir: state_dir), FILE))
+      !raw.nil? && holds?(raw)
+    rescue SystemCallError
       false
     end
 

data/lib/samagotchi/state_format.rb

@@ -22,7 +22,7 @@ module Samagotchi
       end
     end
 
-    Document = Data.define(:version, :extra, :entries)
+    Document = Data.define(:version, :extra, :entries, :attributes)
 
     class InvalidDocument < StandardError; end
 
@@ -38,16 +38,18 @@ module Samagotchi
       Member.new(name: name.to_sym, introduced_in: in_version, default: ->(_attributes) { {} }, persisted: false)
     end
 
-    attr_reader :members
+    attr_reader :members, :document_members
 
-    def initialize(version:, members:)
+    def initialize(version:, members:, document_members: [])
       @version = version
       @members = members.freeze
+      @document_members = document_members.freeze
       @extra_member = members.find { |member| !member.persisted? }
       raise ArgumentError, "a state format can declare only one extra member" if members.count { |member| !member.persisted? } > 1
       raise ArgumentError, "duplicate state format members" unless members.map(&:name).uniq == members.map(&:name)
+      raise ArgumentError, "duplicate state format document members" unless document_members.map(&:name).uniq == document_members.map(&:name)
 
-      members.each do |member|
+      (members + document_members).each do |member|
         required = member.required? && member.default.equal?(REQUIRED)
         defaulted = member.defaulted? && member.introduced_in.is_a?(Integer) &&
                     member.introduced_in.positive? && member.introduced_in <= version &&
@@ -63,17 +65,26 @@ module Samagotchi
 
       collection = collection.to_s
       entries = Array(data[collection]).map { |raw| read_record(raw) }
-      known = %w[version updated_at] + [collection]
+      attributes = {}
+      document_members.each do |member|
+        key = member.name.to_s
+        attributes[member.name] = if data.key?(key)
+                                    data[key]
+                                  else
+                                    default_value(member.default, attributes)
+                                  end
+      end
+      known = %w[version updated_at] + [collection] + document_members.map { |member| member.name.to_s }
       stored_version = data["version"]
       stored_version = 0 unless stored_version.is_a?(Integer) && stored_version >= 0
 
       Document.new(version: [@version, stored_version].max,
                    extra: data.reject { |key, _value| known.include?(key.to_s) },
-                   entries: entries)
+                   entries: entries, attributes: attributes)
     end
 
     def write(document, collection:, updated_at:)
-      document.extra.transform_keys(&:to_s).merge(
+      document.extra.transform_keys(&:to_s).merge(document.attributes.transform_keys(&:to_s)).merge(
         "version" => [document.version, @version].max,
         "updated_at" => updated_at,
         collection.to_s => document.entries.map(&:to_h)

data/lib/samagotchi/system_one/runs.rb

@@ -69,7 +69,12 @@ module Samagotchi
       # Explicit `chi sessions delete`: that session's runs and their later
       # lines go, whatever system_one.runs says now.
       def self.purge_session(session_id, sessions_dir:)
-        RunsStore.new(File.dirname(sessions_dir)).purge_session(session_id)
+        purge_sessions([session_id], sessions_dir: sessions_dir)
+      end
+
+      # A retention sweep's runs, purged with one pass over the store.
+      def self.purge_sessions(session_ids, sessions_dir:)
+        RunsStore.new(File.dirname(sessions_dir)).purge_sessions(session_ids)
       end
 
       # Whether a bundle may declare +name+ (safe as a folder, not core's).

data/lib/samagotchi/system_one/runs_store.rb

@@ -114,16 +114,29 @@ module Samagotchi
       # day files under the lock.
       # @return [Integer] the runs purged
       def purge_session(session_id)
-        needle = session_id.to_s
-        return 0 if needle.empty?
+        purge_sessions([session_id])
+      end
+
+      # Many sessions' runs, found with one pass over the judgment day files.
+      # @return [Integer] the runs purged
+      def purge_sessions(session_ids)
+        needles = Array(session_ids).map(&:to_s).reject(&:empty?).uniq
+        return 0 if needles.empty?
 
         names.sum do |name|
-          files = day_files(name).select { |path| read(path).include?(needle) }
-          ids = files.flat_map { |path| session_run_ids(path, needle) }
+          files = day_files(name)
+          ids = files.flat_map do |path|
+            read(path).each_line.filter_map do |text|
+              next unless needles.any? { |needle| text.include?(needle) }
+
+              data = parse(text)
+              data["id"] if data && data["kind"] == "run" && needles.include?(data["session_id"])
+            end
+          end.uniq
           next 0 if ids.empty?
 
           known = ids.to_h { |id| [id, true] }
-          day_files(name).each { |path| rewrite_without(path, known) }
+          files.each { |path| rewrite_without(path, known) }
           remove_if_empty(name)
           ids.size
         end
@@ -197,15 +210,6 @@ module Samagotchi
         nil
       end
 
-      def session_run_ids(path, session_id)
-        read(path).each_line.filter_map do |text|
-          next unless text.include?(session_id)
-
-          data = parse(text)
-          data["id"] if data && data["kind"] == "run" && data["session_id"] == session_id
-        end
-      end
-
       def rewrite_without(path, ids)
         with_file(path) do |file|
           kept = file.each_line.reject do |text|

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -7,6 +7,7 @@ require_relative "../session_manager"
 require_relative "../thinking_command"
 require_relative "../bridge_client"
 require_relative "../worker_link"
+require_relative "../worker_presence"
 require_relative "../parent_report"
 require_relative "../cli/exit"
 require_relative "../launch_mode"
@@ -154,7 +155,7 @@ module Samagotchi
       def worker_running?(session_id, state_dir)
         return false unless session_id && Session.valid_id?(session_id)
 
-        WorkerLink.resolve(Session.session_dir(session_id, state_dir: state_dir), unlink: false).live?
+        WorkerPresence.read(session_id, state_dir: state_dir, link: :look).live?
       end
 
       # The session's debug records, dim, above the live region.
@@ -261,8 +262,10 @@ module Samagotchi
                     SessionManager.resume_session(resume, state_dir: sd)
                   else
                     SessionManager.spawn_session(prompt: nil, model_name: model && model_ref(model), state_dir: sd,
-                                                 memories: memories, muted_memories: muted_memories,
-                                                 setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
+                                                 client_id: nil,
+                                                 setup: SessionSetup.new(preloaded_memory_names: memories,
+                                                                         muted_memory_names: muted_memories,
+                                                                         llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
                                                                          thinking: Thinking.session_level(thinking),
                                                                          appended_prompt_files: appended_prompt_files,
                                                                          toolkit: toolkit, settings: settings,
@@ -319,7 +322,7 @@ module Samagotchi
       # @raise [Error] its worker is newer than this chi (Skew)
       def connect_existing(session_id, state_dir)
         Session.load(session_id, state_dir: state_dir)
-        link = WorkerLink.resolve(Session.session_dir(session_id, state_dir: state_dir), unlink: true)
+        link = WorkerPresence.read(session_id, state_dir: state_dir, link: :unlink).link
         raise Error, link.message(session_id) if link.is_a?(WorkerLink::Skew)
 
         link.live? ? link.client(session_id) : nil

data/lib/samagotchi/terminal_ui/attached_loop/composer.rb

@@ -12,7 +12,7 @@ module Samagotchi
       # Input composition and Ctrl-C handling for the attached loop.
       # Reads @client, @clock, @command_registry, @continue_offer, @exit_ask,
       # @gaps, @link, @prefilled, @question, @queue, @queued_ids, @reader,
-      # @running, @scratch, @screen; writes @prefilled, @last_idle_interrupt_at.
+      # @running, @running_turn_id, @scratch, @screen; writes @prefilled, @last_idle_interrupt_at.
       # Calls the loop helpers #answer_continue, #answer_exit_ask, #answer_question,
       # #archive_after_turn, #command_registry, #detach, #echo_answer, #exit_and_archive,
       # #end_scratch, #exit_and_delete, #exit_worker, #refuse_scratch_archive, #gap_divider,
@@ -185,7 +185,10 @@ module Samagotchi
           typed = pressed&.fetch(:text, nil).to_s
           if @running
             begin
-              @client.cancel(reason: "ctrl_c")
+              # Names the turn this terminal shows, so a Ctrl-C as it ends
+              # doesn't stop the next one; a snapshot without an id sends none.
+              reply = @client.cancel(reason: "ctrl_c", **{ turn_id: @running_turn_id }.compact)
+              @screen.commit("a new turn started; Ctrl-C again stops it") if reply&.status == 409 && reply.json&.dig("error") == "turn_mismatch"
             rescue SystemCallError, IOError => e
               @screen.commit("could not cancel the turn (#{worker_down(e)})")
             end

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -138,6 +138,7 @@ module Samagotchi
         @renderer = EventRenderer.new(@view)
         @shown_enqueued = Set.new
         @running = false
+        @running_turn_id = nil
         @joined_mid_turn = false
         @attached = false
         # The stream moved to a new worker; its snapshot resyncs (#switch_worker).
@@ -593,6 +594,7 @@ module Samagotchi
 
       def render_current_turn(turn)
         @running = !turn.nil?
+        @running_turn_id = turn&.dig(:turn_id)
         @joined_mid_turn = @running
         # A turn running at the join: the status row's steer hint.
         @status.update(running: @running)
@@ -628,6 +630,7 @@ module Samagotchi
 
       def start_turn(event)
         @running = true
+        @running_turn_id = event[:turn_id]
         @joined_mid_turn = false
         origin = origin_of(event[:origin])
         @my_queued.delete(origin.enqueued_id)
@@ -663,12 +666,14 @@ module Samagotchi
         # The turn's summary carries its last context estimate.
         @status.update(context: @view.context_status) if @view.context_status
         @running = false
+        @running_turn_id = nil
         @joined_mid_turn = false
         close_question("(the turn ended)") if @question
       end
 
       def end_turn
         @running = false
+        @running_turn_id = nil
         @joined_mid_turn = false
         close_question("(the turn ended)") if @question
       end

data/lib/samagotchi/terminal_ui/version_lines.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../installed_versions"
+require_relative "../compat"
 require_relative "../version"
 require_relative "../chi_invocation"
 
@@ -24,7 +25,7 @@ module Samagotchi
 
         newest = [installed, terminal].select { |v| Gem::Version.correct?(v.to_s) && !v.to_s.empty? }
                                       .max_by { |v| Gem::Version.new(v) }
-        worker_old = InstalledVersions.newer?(newest, worker)
+        worker_old = Compat.verdict(worker_version: worker, version: newest) == :restart_suggested
         terminal_old = InstalledVersions.newer?(newest, terminal)
         return nil unless worker_old || terminal_old
 
@@ -51,7 +52,8 @@ module Samagotchi
       def across_machines(worker:, installed:, session_id:, terminal:, via:)
         there = [installed, worker].select { |v| Gem::Version.correct?(v.to_s) && !v.to_s.empty? }
                                    .max_by { |v| Gem::Version.new(v) }
-        worker_old = InstalledVersions.newer?(installed, worker)
+        worker_old = installed && !installed.to_s.empty? &&
+                     Compat.verdict(worker_version: worker, version: installed) == :restart_suggested
         terminal_old = InstalledVersions.newer?(there, terminal)
         return nil unless worker_old || terminal_old
 

data/lib/samagotchi/terminal_ui.rb

@@ -189,12 +189,11 @@ module Samagotchi
         mode: "assist",
         model_name: @effective_model_name,
         working_directory: Dir.pwd,
-        preloaded_memory_names: @requested_memories,
-        muted_memory_names: @muted_memory_names,
         scratch: @scratch,
         setup: SessionSetup.new(appended_prompt_files: @appended_prompt_files, toolkit: @toolkit || Toolkit.configured,
                                 toolkit_origin: @toolkit ? "chosen" : "default", settings: @session_settings,
-                                parent_answers: @parent_answers)
+                                parent_answers: @parent_answers, preloaded_memory_names: @requested_memories,
+                                muted_memory_names: @muted_memory_names)
       ))
       # --llm-context*: the session's own values, over a resumed one's.
       # Saved at once on a resumed one: leaving before a turn keeps them.