samagotchi 0.7.0 → 0.8.0

data/lib/samagotchi/session_manager.rb

@@ -6,12 +6,15 @@ require "json"
 require "time"
 require "securerandom"
 require "rbconfig"
+require_relative "atomic_file"
 
 require_relative "session"
+require_relative "session_inbox"
 require_relative "session_metrics"
 require_relative "turn_note"
 require_relative "owner_lock"
 require_relative "bridge_client"
+require_relative "worker_sidecar"
 require_relative "log"
 require_relative "log_path"
 require_relative "installed_gem"
@@ -29,46 +32,27 @@ module Samagotchi
   # The session itself (messages + metadata) is always saved by Session at
   # <sessions dir>/<session_id>.json, for foreground chats too. A sibling
   # directory holds the owner lock (any owner, TUI included) and, for
-  # background workers, their IPC files:
+  # background workers, their IPC files (input/, notes/ and output/ are
+  # SessionInbox's):
   #   ~/.local/state/samagotchi/sessions/
   #   ├── <session_id>.json       # the session (Session#save)
   #   └── <session_id>/
   #       ├── owner.lock          # flock held by the session's one owner (OwnerLock)
   #       ├── input/              # clients (web/terminal UI) write messages here
   #       │   └── <timestamp>.json # one file per user message: {prompt, client_id,
-  #       │                        # enqueued_id} (plain <timestamp>.txt for old workers)
+  #       │                        # enqueued_id, no_interrupt?, images?}
   #       ├── notes/              # context notes: background text the worker adds to
   #       │   └── <ts>-<rand>.json # the conversation between turns, never a turn
   #       │                        # ({text, source, from_session?, from_cwd?, created_at})
   #       ├── output/             # agent writes responses here
   #       │   └── <timestamp>.txt # one file per agent response
-  #       ├── pid                 # PID of the owner, written by the owner itself
   #       └── bridge.json         # Bridge sidecar (how clients reach the worker)
   # Needed only at call time (run_session_loop); worker.rb requires this file.
   autoload :Worker, File.expand_path("worker", __dir__)
+  # session_retention requires this file.
+  autoload :SessionRetention, File.expand_path("session_retention", __dir__)
 
   class SessionManager
-    INPUT_DIR  = "input"
-    # Context notes live apart from input/, so nothing that reads input/
-    # (the mid-turn drain, the idle-exit hold, the Waker) ever sees one.
-    NOTES_DIR  = "notes"
-    NOTE_MAX_BYTES = 16 * 1024
-    OUTPUT_DIR = "output"
-    PID_FILE   = "pid"
-    # Input-file format this worker reads, advertised in the Bridge sidecar:
-    #   2  JSON with the sender's ids (and plain text)
-    #   3  images: refs too
-    # A worker that doesn't advertise one reads only .txt, and such workers
-    # never exit.
-    INPUT_FORMAT = 3
-    STRUCTURED_INPUT_FORMAT = 2
-    IMAGES_INPUT_FORMAT = 3
-
-    # A turn with images for a worker older than IMAGES_INPUT_FORMAT, which
-    # would drop them.
-    class ImagesUnsupported < StandardError
-      def initialize(msg = "this session's worker predates images: restart it (/exit, then resume)") = super
-    end
     # Origin of the synthetic turn queued when reminders are due.
     REMINDER_CLIENT_ID = "system:reminder"
 
@@ -85,10 +69,6 @@ module Samagotchi
       end
     end
 
-    # A note (or a `chi send` message) that can't go in: empty, or over
-    # NOTE_MAX_BYTES.
-    class NoteRejected < ArgumentError; end
-
     # A delete that would pull the session from under its live worker.
     # reason: :worker_running (not asked to stop it) or :still_stopping
     # (stopped, but the worker outlived the wait).
@@ -222,7 +202,6 @@ module Samagotchi
                    offset: offset, project_root: project_root, include_archived: include_archived)
     end
 
-    # Prune sessions per retention policy. Delegates to Session.prune with live-worker guard.
     SUMMARY_DESC_LIMIT = 60
 
     # Short summaries of sessions, newest first: the picker behind
@@ -322,7 +301,7 @@ module Samagotchi
 
     private_class_method def self.archive_target(id_or_prefix, state_dir)
       given = id_or_prefix.to_s
-      raise ArgumentError, "no session #{given}" unless given.match?(/\A[\w-]+\z/)
+      raise ArgumentError, "no session #{given}" unless Session.valid_id?(given)
 
       id = Session.resolve_id(given, state_dir: state_dir)
       raise ArgumentError, "no session #{given}" unless Session.exist?(id, state_dir: state_dir)
@@ -385,107 +364,9 @@ module Samagotchi
       dir == root || dir.start_with?("#{root}/")
     end
 
-    def self.prune_sessions(state_dir: nil, days: nil, max_count: nil, keep_status: nil, dry_run: false, test_only: false,
-                            any_age: false)
-      sd = state_dir || Session.default_state_dir
-      days = resolve_retention_days(days)
-      max_count = resolve_retention_max_count(max_count)
-      keep_status = resolve_retention_keep_status(keep_status)
-      discard = discard_empty?
-      default_model = discard ? (begin ModelProfile.required_model_name(nil) rescue nil end) : nil
-      result = Session.prune(
-        state_dir: sd,
-        days: days,
-        max_count: max_count,
-        keep_status: keep_status,
-        dry_run: dry_run,
-        test_only: test_only,
-        any_age: any_age,
-        alive_check: ->(sid) { worker_alive_for_session?(sid, state_dir: 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
-
-    # How long a session may sit empty before the sweep takes it: its
-    # worker (or a REPL) deletes it as it leaves, so the sweep only catches
-    # those killed first (a reboot, kill -9).
-    EMPTY_GRACE_SECONDS = 3600
-
-    private_class_method def self.left_empty?(session_id, state_dir:, default_model:)
-      path = File.join(state_dir, "#{session_id}#{Session::FILE_EXT}")
-      Time.now - File.mtime(path) > EMPTY_GRACE_SECONDS &&
-        empty_session?(session_id, state_dir: state_dir, default_model: default_model)
-    rescue SystemCallError
-      false
-    end
-
-    # Directories with no session file and nothing but the skeleton, nobody
-    # owning them: a REPL killed before its first save, or a worker woken
-    # just as its session was discarded.
-    # @return [Array<String>] their ids
-    private_class_method def self.prune_orphan_dirs(state_dir, dry_run:)
-      return [] unless Dir.exist?(state_dir)
-
-      Dir.children(state_dir).filter_map do |name|
-        dir = File.join(state_dir, name)
-        next unless name.match?(/\A[\w-]+\z/) && File.directory?(dir)
-        next if File.exist?(File.join(state_dir, "#{name}#{Session::FILE_EXT}"))
-        next unless Time.now - File.mtime(dir) > EMPTY_GRACE_SECONDS && empty_session_dir?(dir)
-        next if session_owner(name, state_dir: state_dir)
-
-        FileUtils.rm_rf(dir) unless dry_run
-        name
-      rescue SystemCallError
-        nil
-      end
-    end
-
-    # Lazy sweep guard: runs prune at most once per RETENTION_SWEEP_INTERVAL_HOURS.
-    RETENTION_MARKER = ".last_retention"
-    RETENTION_SWEEP_INTERVAL_HOURS = 24
-
-    def self.retention_sweep_if_due(state_dir: nil)
-      sd = state_dir || Session.default_state_dir
-      return unless Dir.exist?(sd)
-
-      hours = Samagotchi::Config.get("session.sweep_interval_hours").to_i
-      interval = (hours.positive? ? hours : RETENTION_SWEEP_INTERVAL_HOURS) * 3600
-      marker = File.join(sd, RETENTION_MARKER)
-      if File.exist?(marker)
-        age = Time.now - File.mtime(marker)
-        return if age < interval
-      end
-      result = prune_sessions(state_dir: sd)
-      FileUtils.touch(marker)
-      if result[:deleted].any?
-        Log.info(:worker, "retention_pruned", echo: "[retention] pruned #{result[:deleted].size} sessions (kept #{result[:kept].size})", deleted: result[:deleted].size, kept: result[:kept].size)
-      end
-      result
-    rescue StandardError => e
-      Log.warn(:worker, "retention_failed", echo: "[retention] sweep failed: #{e.class}: #{e.message}", error: e.class.name)
-      nil
-    end
-
-    # The caller's value (a sessions prune flag) or session.retention_days.
-    private_class_method def self.resolve_retention_days(val)
-      return val.to_i if !val.nil? && val.to_s.strip != ""
-
-      Samagotchi::Config.get("session.retention_days").to_i
-    end
-
-    private_class_method def self.resolve_retention_max_count(val)
-      return val.to_i if !val.nil? && val.to_s.strip != ""
-
-      Samagotchi::Config.get("session.max_count").to_i
-    end
-
-    # A comma list of statuses never pruned; "" keeps none.
-    private_class_method def self.resolve_retention_keep_status(val)
-      raw = !val.nil? && val.to_s.strip != "" ? val.to_s : Samagotchi::Config.get("session.keep_status").to_s
-      raw.split(",").map(&:strip).reject(&:empty?)
-    end
+    # The retention sweep (SessionRetention.sweep_if_due), here for the web
+    # app and hub, which take this class as their manager.
+    def self.retention_sweep_if_due(state_dir: nil) = SessionRetention.sweep_if_due(state_dir: state_dir)
 
     # Ensure an existing session has a live worker process.
     # Returns the loaded session after state reconciliation.
@@ -508,17 +389,8 @@ module Samagotchi
     # Read any new output files from a session directory.
     # Optionally filters to only files newer than `since_time`.
     def self.read_responses(session_id, since_time: nil, state_dir: nil)
-      session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
-      output_path = File.join(session_dir, OUTPUT_DIR)
-      responses = []
-      return responses unless Dir.exist?(output_path)
-
-      Dir.glob(File.join(output_path, "*.txt")).sort.each do |f|
-        if since_time.nil? || File.mtime(f) > since_time
-          responses << File.read(f)
-        end
-      end
-      responses
+      SessionInbox.read_outputs(Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir),
+                                since_time: since_time)
     end
 
     # Stop a session by sending TERM to its process.
@@ -568,10 +440,12 @@ module Samagotchi
 
     # What a session's directory holds before anything happened in it. Any
     # other entry (or a file in one of the EMPTY_DIRS) is something the
-    # session keeps.
-    EMPTY_SKELETON_FILES = %w[pid owner.lock bridge.json analytics.json].freeze
-    EMPTY_DIRS = [INPUT_DIR, NOTES_DIR, "images"].freeze
-    EMPTY_SKELETON_DIRS = (EMPTY_DIRS + [OUTPUT_DIR]).freeze
+    # session keeps. "pid" is the pid file workers wrote until 2026-10-01:
+    # nothing writes or reads it now, but a folder from before still has one
+    # and is still empty.
+    EMPTY_SKELETON_FILES = ["pid", "owner.lock", WorkerSidecar::FILE, "analytics.json"].freeze
+    EMPTY_DIRS = [SessionInbox::INPUT_DIR, SessionInbox::NOTES_DIR, "images"].freeze
+    EMPTY_SKELETON_DIRS = (EMPTY_DIRS + [SessionInbox::OUTPUT_DIR]).freeze
 
     # session.keep_empty off: sessions left with nothing in them are deleted
     # (the worker as it exits, the TUI at /exit, the retention sweep).
@@ -581,6 +455,29 @@ module Samagotchi
       false
     end
 
+    # Whether a session being left (or found left) is deleted: session.keep_empty
+    # is off and nothing happened in it (#empty_session?). The worker as it
+    # leaves, the REPL at /exit and the retention sweep all ask this.
+    # @param default_model [String, nil] what a new session starts on
+    # @param model_name [String, nil] the model its owner runs now (the REPL
+    #   keeps /model in its Engine); the saved one is checked either way
+    # @param used_memory_names [Array<String>] memory its owner's Engine used
+    #   before any save
+    # @param unsaved [Session, nil] the REPL's working copy, judged instead
+    #   when the session was never saved
+    def self.discardable?(session_id, default_model:, state_dir: nil, model_name: default_model, used_memory_names: [],
+                          unsaved: nil)
+      return false unless discard_empty? && model_name == default_model && Array(used_memory_names).empty?
+
+      sd = state_dir || Session.default_state_dir
+      if unsaved && !File.exist?(Session.session_file(session_id, state_dir: sd))
+        return no_conversation?(unsaved.messages) && unsaved.last_prompt.to_s.strip.empty? &&
+               empty_session_dir?(Session.session_dir(session_id, state_dir: sd))
+      end
+
+      empty_session?(session_id, state_dir: sd, default_model: default_model)
+    end
+
     # A session nothing happened in: no conversation, no turn tried (a failed
     # one leaves no messages but a last_prompt and analytics turns), nothing
     # queued or attached, and the model and mode a new session gets. A
@@ -641,10 +538,10 @@ module Samagotchi
       sd = state_dir || Session.default_state_dir
       given = id_or_prefix.to_s
       # Only a plain id: anything else could name a path outside the state dir.
-      raise ArgumentError, "no session #{given}" unless given.match?(/\A[\w-]+\z/)
+      raise ArgumentError, "no session #{given}" unless Session.valid_id?(given)
 
       id = Session.resolve_id(given, state_dir: sd)
-      path = File.join(sd, "#{id}#{Session::FILE_EXT}")
+      path = Session.session_file(id, state_dir: sd)
       dir = Session.session_dir(id, state_dir: sd)
       raise ArgumentError, "no session #{given}" unless File.exist?(path) || Dir.exist?(dir)
 
@@ -713,7 +610,6 @@ module Samagotchi
       worker = Worker.new(session_id: session_id, state_dir: sd, session_dir: session_dir,
                           idle_exit_minutes: idle_exit_minutes, poll_interval: poll_interval)
       result = begin
-        File.write(File.join(session_dir, PID_FILE), Process.pid.to_s)
         worker.run
       rescue StandardError, ScriptError => e
         # The worker's stderr is /dev/null: the log is the only trace.
@@ -726,7 +622,7 @@ module Samagotchi
       # Only after the release: a writer that still saw this worker as the
       # owner may have queued input since the last check. Either it finds no
       # owner after its write and wakes one, or this finds its input.
-      if %i[idle_exit exit_requested].include?(result) && !find_new_input_files(session_dir).empty?
+      if %i[idle_exit exit_requested].include?(result) && !SessionInbox.find_new_input_files(session_dir).empty?
         resume_session(session_id, state_dir: sd)
       elsif worker.discard?
         discard_left_session(session_id, state_dir: sd, default_model: worker.default_model)
@@ -740,7 +636,7 @@ module Samagotchi
     # landing between this check and the delete fails with "no session"
     # (a window of an empty session's last moments, left as is).
     private_class_method def self.discard_left_session(session_id, state_dir:, default_model:)
-      return unless empty_session?(session_id, state_dir: state_dir, default_model: default_model)
+      return unless discardable?(session_id, state_dir: state_dir, default_model: default_model)
 
       delete_session(session_id, state_dir: state_dir)
       Log.info(:worker, "discarded_empty", sid: session_id)
@@ -756,8 +652,8 @@ module Samagotchi
 
     private_class_method def self.setup_session_directory(session_dir, session, state_dir:)
       FileUtils.mkdir_p(session_dir)
-      FileUtils.mkdir_p(File.join(session_dir, INPUT_DIR))
-      FileUtils.mkdir_p(File.join(session_dir, OUTPUT_DIR))
+      FileUtils.mkdir_p(File.join(session_dir, SessionInbox::INPUT_DIR))
+      FileUtils.mkdir_p(File.join(session_dir, SessionInbox::OUTPUT_DIR))
       session.save(state_dir: state_dir)
     end
 
@@ -776,13 +672,12 @@ module Samagotchi
     private_class_method def self.spawn_worker_for_session(session, state_dir:)
       session_dir = Session.session_dir(session.id, state_dir: state_dir)
       FileUtils.mkdir_p(session_dir)
-      FileUtils.mkdir_p(File.join(session_dir, INPUT_DIR))
-      FileUtils.mkdir_p(File.join(session_dir, OUTPUT_DIR))
+      FileUtils.mkdir_p(File.join(session_dir, SessionInbox::INPUT_DIR))
+      FileUtils.mkdir_p(File.join(session_dir, SessionInbox::OUTPUT_DIR))
 
       opts = spawn_options(session)
       env = opts.delete(:env)
       command = worker_command(session.id, state_dir: state_dir)
-      # The worker writes the pid file itself once it owns the session.
       pid = env ? Process.spawn(env, *command, **opts) : Process.spawn(*command, **opts)
       Log.info(:worker, "spawn", sid: session.id, child_pid: pid)
       pid
@@ -802,7 +697,7 @@ module Samagotchi
                           exit_discards: nil)
       require_relative "bridge"
       Samagotchi::Bridge.new(
-        engine: engine, state_dir: state_dir, session_id: session_id, input_format: INPUT_FORMAT,
+        engine: engine, state_dir: state_dir, session_id: session_id, input_format: SessionInbox::INPUT_FORMAT,
         on_input: on_input, on_command: on_command, on_exit_request: on_exit_request, exit_discards: exit_discards
       ).start
     rescue StandardError => e
@@ -810,26 +705,20 @@ module Samagotchi
       nil
     end
 
-
-
     # Write a user turn into a session's input directory via the same file IPC
     # the worker polls. Reused by the bridge's POST surface so a turn is
     # fire-and-forget and never calls run_turn across the thread/process
-    # boundary. The file is JSON carrying the sender's ids, unless the
-    # session's live worker predates structured input (plain text then).
+    # boundary. The file is JSON carrying the sender's ids.
     # @param client_id [String, nil] the sending UI
     # @param enqueued_id [String, nil] the id its ACK / :turn_enqueued carry
     # @param images [Array<Hash>] image refs ({file:, name:}) in the
-    #   session's images/ (raises ImagesUnsupported for an older worker)
+    #   session's images/
     # @return [String, false] the input file's path, or false.
     def self.write_turn_input(session_id, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, state_dir: nil,
                               images: [])
-      sd = state_dir || Session.default_state_dir
-      session_dir = Session.session_dir(session_id, state_dir: sd)
-      images = Array(images)
-      raise ImagesUnsupported if !images.empty? && !images_input?(session_dir)
-
-      write_input_file(session_dir, prompt, client_id, enqueued_id, no_interrupt, images)
+      session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
+      SessionInbox.write_input(session_dir, prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
+                                            no_interrupt: no_interrupt, images: images)
     end
 
     # How long a turn waits for the Bridge of a worker a resume just spawned.
@@ -852,16 +741,11 @@ module Samagotchi
     #   ack:} when it took the request but never answered (no file then), or
     #   {status: :failed} when the input file couldn't be written
     # @raise [OwnedByTUI] a chi REPL owns the session
-    # @raise [ImagesUnsupported] images for a worker that predates them
     # @raise [ArgumentError] no such session
     def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], state_dir: nil, manager: self, bridge: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
       manager.resume_session(session_id, state_dir: state_dir) if manager.respond_to?(:resume_session)
-      # A worker that predates images would drop them (its Bridge ignores
-      # them): refuse, so the sender keeps the chips and the text.
-      raise ImagesUnsupported if images.any? && !images_input?(session_dir)
-
       if (client = bridge.call)
         begin
           options = { prompt: prompt, client_id: client_id }
@@ -869,7 +753,7 @@ module Samagotchi
           reply = client.post_turn(**options)
           ack = reply.json
           return { status: :accepted, ack: ack } if reply.status == 202 && ack.is_a?(Hash)
-          if ack.is_a?(Hash) && %w[bad_images images_unsupported].include?(ack["error"])
+          if ack.is_a?(Hash) && ack["error"] == "bad_images"
             return { status: :refused, code: reply.status, ack: ack }
           end
           # Read after its deadline and dropped: a file would run it after all.
@@ -917,203 +801,18 @@ module Samagotchi
       nil
     end
 
-    private_class_method def self.write_input_file(session_dir, prompt, client_id, enqueued_id, no_interrupt, images)
-      input_dir = File.join(session_dir, INPUT_DIR)
-      FileUtils.mkdir_p(input_dir)
-
-      timestamp = Time.now.strftime("%Y%m%d%H%M%S%9N")
-      if structured_input?(session_dir)
-        path = File.join(input_dir, "#{timestamp}.json")
-        record = { "prompt" => prompt.to_s, "client_id" => client_id, "enqueued_id" => enqueued_id,
-                   "no_interrupt" => (no_interrupt ? true : nil),
-                   "images" => (images.empty? ? nil : images.map { |image| image.transform_keys(&:to_s) }) }.compact
-        write_atomic(path, JSON.generate(record))
-      else
-        path = File.join(input_dir, "#{timestamp}.txt")
-        write_atomic(path, prompt.to_s)
-      end
-      path
-    rescue StandardError
-      false
-    end
-
-    # Queue a context note for a session: background text its worker adds
-    # to the conversation between turns. It never starts a turn.
-    # @param source [String] where it came from ("cli", "slack", "session")
-    # @param from_session [String, nil] the sending session, for a peer's note
-    # @return [String] the note file's path
-    # @raise [NoteRejected] for an empty note or one over 16 KiB (never cut)
-    def self.write_note(session_id, text:, source: "cli", from_session: nil, from_cwd: nil, state_dir: nil)
-      body = checked_text(text)
-      sd = state_dir || Session.default_state_dir
-      notes_dir = File.join(Session.session_dir(session_id, state_dir: sd), NOTES_DIR)
-      FileUtils.mkdir_p(notes_dir)
-
-      # The random part keeps two writers in one nanosecond apart; the
-      # timestamp keeps the names in arrival order.
-      name = "#{Time.now.strftime("%Y%m%d%H%M%S%9N")}-#{SecureRandom.hex(3)}.json"
-      path = File.join(notes_dir, name)
-      record = { "text" => body, "source" => source.to_s, "from_session" => from_session,
-                 "from_cwd" => from_cwd, "created_at" => Time.now.iso8601 }.compact
-      write_atomic(path, JSON.generate(record))
-      path
-    end
-
-    # The same empty and 16 KiB checks for a note and a sent message.
-    # @param noun [String] what the errors call the text
-    # @return [String] the stripped text
-    # @raise [NoteRejected]
-    def self.checked_text(text, noun: "note")
-      body = text.to_s.strip
-      raise NoteRejected, "the #{noun} is empty" if body.empty?
-      if body.bytesize > NOTE_MAX_BYTES
-        raise NoteRejected, "the #{noun} is #{body.bytesize} bytes; the limit is 16 KiB (#{NOTE_MAX_BYTES} bytes)"
-      end
-
-      body
-    end
-
-    # Queued notes, oldest first, plus any a crashed worker claimed and left
-    # (the absorber skips a note id the conversation already holds).
-    def self.find_new_note_files(session_dir)
-      notes_dir = File.join(session_dir, NOTES_DIR)
-      return [] unless Dir.exist?(notes_dir)
-
-      Dir.glob(File.join(notes_dir, "*.{json,json.processing}")).sort_by { |p| File.basename(p) }
-    end
-
-    # @return [String, nil] the claimed path, or nil when another claimed it
-    def self.claim_note_file(note_file)
-      return note_file if note_file.end_with?(".processing")
-
-      claim_input_file(note_file)
-    end
-
-    # @return [Hash, nil] {note_id:, text:, source:, from_session:, from_cwd:,
-    #   created_at:}, or nil for a file that holds no usable note
-    def self.read_note(note_file)
-      data = JSON.parse(File.read(note_file))
-      text = data["text"].to_s.strip
-      return nil if text.empty?
-
-      { note_id: File.basename(note_file).sub(/\.json(\.processing)?\z/, ""), text: text,
-        source: data["source"].to_s.empty? ? "cli" : data["source"].to_s,
-        from_session: data["from_session"], from_cwd: data["from_cwd"], created_at: data["created_at"] }
-    rescue JSON::ParserError, SystemCallError, NoMethodError, TypeError
-      nil
-    end
-
-    def self.write_output(session_dir, response)
-      output_dir = File.join(session_dir, OUTPUT_DIR)
-      FileUtils.mkdir_p(output_dir)
-      timestamp = Time.now.strftime("%Y%m%d%H%M%S%9N")
-      write_atomic(File.join(output_dir, "#{timestamp}.txt"), response.to_s)
-    end
-
-    def self.find_new_input_files(session_dir)
-      input_dir = File.join(session_dir, INPUT_DIR)
-      return [] unless Dir.exist?(input_dir)
-
-      Dir.glob(File.join(input_dir, "*.{txt,json}"))
-    end
-
-    # A worker's sidecar advertises the input format it reads; no sidecar
-    # means no worker yet, and the next one (this code) reads JSON.
-    private_class_method def self.structured_input?(session_dir)
-      worker_input_format(session_dir) >= STRUCTURED_INPUT_FORMAT
-    end
-
-    # Whether the session's worker (or the next one) reads images: refs.
-    def self.images_input?(session_dir)
-      worker_input_format(session_dir) >= IMAGES_INPUT_FORMAT
-    end
-
-    # The input format the session's worker advertises; no sidecar means no
-    # worker yet, and the next one (this code) reads INPUT_FORMAT.
-    private_class_method def self.worker_input_format(session_dir)
-      sidecar = File.join(session_dir, "bridge.json")
-      return INPUT_FORMAT unless File.file?(sidecar)
-
-      JSON.parse(File.read(sidecar))["input_format"].to_i
-    rescue JSON::ParserError, SystemCallError
-      INPUT_FORMAT
-    end
-
-    # @return [Array(String, Hash|nil, Boolean, Array<Hash>)] a claimed input
-    #   file's prompt, origin ({client_id:, enqueued_id:}, nil for plain
-    #   text), whether its turn runs with the raised iteration limit
-    #   (--no-interrupt), and its image refs ({file:, name:})
-    def self.read_input(claimed_file)
-      raw = File.read(claimed_file).to_s
-      return [raw, nil, false, []] unless claimed_file.end_with?(".json.processing")
-
-      data = JSON.parse(raw)
-      origin = { client_id: data["client_id"], enqueued_id: data["enqueued_id"] }.compact
-      images = Array(data["images"]).select { |image| image.is_a?(Hash) }.map { |image| image.transform_keys(&:to_sym) }
-      [data["prompt"].to_s, origin.empty? ? nil : origin, data["no_interrupt"] == true, images]
-    rescue JSON::ParserError
-      [nil, nil, false, []]
-    end
-
-    # Whether an unclaimed input file carries images (a mid-turn drain
-    # leaves it for its own turn).
-    def self.input_has_images?(input_file)
-      return false unless input_file.end_with?(".json")
-
-      data = JSON.parse(File.read(input_file))
-      data.is_a?(Hash) && Array(data["images"]).any?
-    rescue JSON::ParserError, SystemCallError
-      false
-    end
-
-    def self.claim_input_file(input_file)
-      processing_path = "#{input_file}.processing"
-      File.rename(input_file, processing_path)
-      processing_path
-    rescue Errno::ENOENT, Errno::EACCES
-      nil
-    end
-
     def self.stopped_on_disk?(session_id, state_dir:)
       Session.load(session_id, state_dir: state_dir).status == Session::STATUS_STOPPED
     rescue ArgumentError
       false
     end
 
-    private_class_method def self.write_atomic(path, content)
-      temp_path = "#{path}.tmp"
-      File.write(temp_path, content)
-      File.rename(temp_path, path)
-    end
-
-    # The session's live owner: the OwnerLock holder, or a live pid-only
-    # worker started before the lock existed (such workers never exit).
+    # The session's live owner: the OwnerLock holder. The pid file workers
+    # once wrote is never read: a stale one whose pid the OS reused would
+    # make a session look owned.
     # @return [Hash, nil] {"pid", "kind" ("worker"/"tui"), ...} or nil
     def self.session_owner(session_id, state_dir: nil)
-      session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
-      return OwnerLock.owner(session_dir) if OwnerLock.lock_file?(session_dir)
-
-      pid = legacy_worker_pid(session_dir)
-      pid && { "pid" => pid, "kind" => "worker" }
-    end
-
-    private_class_method def self.worker_alive_for_session?(session_id, state_dir:)
-      !session_owner(session_id, state_dir: state_dir).nil?
-    end
-
-    private_class_method def self.legacy_worker_pid(session_dir)
-      pid_file = File.join(session_dir, PID_FILE)
-      return nil unless File.exist?(pid_file)
-
-      pid = File.read(pid_file).strip.to_i
-      return nil if pid <= 0
-
-      Process.kill(0, pid)
-      pid
-    rescue Errno::EPERM
-      pid
-    rescue Errno::ESRCH
-      nil
+      OwnerLock.owner(Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir))
     end
   end
 end

data/lib/samagotchi/session_metrics.rb

@@ -5,6 +5,7 @@ require "monitor"
 require "time"
 require "fileutils"
 require "securerandom"
+require_relative "atomic_file"
 require_relative "session"
 
 module Samagotchi
@@ -247,9 +248,7 @@ module Samagotchi
       # File.join.
       FileUtils.mkdir_p(dir = session_dir(sid, state_dir || @state_dir))
       path = File.join(dir, "analytics.json")
-      temp_path = "#{path}.tmp"
-      File.write(temp_path, JSON.pretty_generate(snapshot.merge(active_turn: nil, active_tools: [])) + "\n")
-      File.rename(temp_path, path)
+      AtomicFile.write(path, JSON.pretty_generate(snapshot.merge(active_turn: nil, active_tools: [])) + "\n")
       true
     rescue StandardError
       false