samagotchi 0.52.0 → 0.54.0

data/lib/samagotchi/session_manager.rb

@@ -6,6 +6,7 @@ require "time"
 require "securerandom"
 require "rbconfig"
 require_relative "client_id"
+require_relative "analytics_file"
 require_relative "atomic_file"
 require_relative "config"
 require_relative "delivery"
@@ -64,6 +65,8 @@ module Samagotchi
   autoload :Worker, File.expand_path("worker", __dir__)
   # session_retention requires this file.
   autoload :SessionRetention, File.expand_path("session_retention", __dir__)
+  # session_continue requires this file.
+  autoload :SessionContinue, File.expand_path("session_continue", __dir__)
 
   class SessionManager
     # Raised when the interactive TUI owns the session: it runs its own Engine
@@ -119,35 +122,6 @@ module Samagotchi
       end
     end
 
-    # A continue that can't happen (#continue_session). reason: :continued
-    # (another session continues it already: +ids+ names it), :open_children
-    # (open children it can't move to the new link: on an older chi's
-    # worker or open in a chi REPL; +ids+ names them) or :folder_gone (its
-    # folder isn't there).
-    class ContinueRefused < StandardError
-      attr_reader :session_id, :reason, :ids
-
-      def initialize(session_id, reason, ids: [], detail: nil)
-        @session_id = session_id
-        @reason = reason
-        @ids = ids
-        super(continue_refused_message(detail))
-      end
-
-      private
-
-      def continue_refused_message(detail)
-        short = @session_id[0, 8]
-        case @reason
-        when :continued then "#{short} is continued already, by #{@ids.first[0, 8]}; continue that one (or last:#{short})"
-        when :open_children
-          "#{short} has delegates still open that can't move to the next link: #{detail}; " \
-          "then continue (or wait for them, stop them or archive them)"
-        else "#{short}'s folder #{detail} is gone"
-        end
-      end
-    end
-
     # Spawn a new background session that processes the given prompt (or,
     # with none, waits idle for input).
     #
@@ -167,7 +141,7 @@ module Samagotchi
     # @param setup [SessionSetup] the session's own settings (chi
     #   --llm-context; a fork and a continue copy their session's)
     # @param continues [String, nil] the session this one continues (a
-    #   session field; #continue_session)
+    #   session field; SessionContinue)
     # @param note [String, nil] a context note the session starts with,
     #   from +note_source+: queued before its worker spawns, so its first
     #   turn sees it
@@ -222,227 +196,9 @@ module Samagotchi
       session
     end
 
-    # How long #continue_session waits for the previous link's worker to
-    # write its recap (IdleRecap's own request timeout).
-    CONTINUE_RECAP_WAIT = 30.0
-    # In the previous link's folder: one continue of a session at a time.
-    CONTINUE_LOCK = "continue.lock"
-    # How often a last:<id> continue looks again when another continue
-    # moved the chain's end while it waited for the lock.
-    CONTINUE_TRIES = 3
-
-    # Start the next link of a chain: a new session that continues
-    # +id_or_ref+ (Session#continues) in its folder, on its model (the name
-    # it was typed as, so an alias holds) and with its own setup (SessionSetup),
-    # starting with a context note from chi: the link and the previous
-    # link's recap (SessionChain.note_text). The previous link is archived
-    # first, with its finished delegates (archive_session's rules: a turn
-    # running, a prompt queued or the step-limit question refuse; an idle
-    # worker is stopped), so a refusal starts nothing. Its open delegates
-    # (running, waiting, live, an unreported reply, at any depth below them)
-    # move to the new link instead (ChildMove): their reports reach it.
-    # Before that its live worker is asked for a recap and given up to
-    # +recap_wait+ seconds to write it.
-    # One continue of a session at a time (a lock in its folder): a double
-    # click finds the first one's link and is refused; a last:<id> one
-    # follows the chain to its new end instead.
-    # @param id_or_ref [String] an id, a prefix, or last:<id> (SessionChain.resolve)
-    # @param prompt [String, nil] its first message (nil: it starts idle)
-    # @param title [String, nil] what the lists show before the first turn;
-    #   by default the prompt, else the previous link's preview
-    # @return [Session] the new link (#model_warning as spawn_session's,
-    #   #moved_children: the delegates it took over)
-    # @raise [ArgumentError] no such session (Session::AmbiguousId for a prefix of several)
-    # @raise [ContinueRefused] continued already, delegates open that can't
-    #   move, or its folder is gone
-    # @raise [ArchiveRefused, OwnedByTUI] as archive_session
-    def self.continue_session(id_or_ref, prompt: nil, title: nil, state_dir: nil, recap_wait: CONTINUE_RECAP_WAIT,
-                              archive_wait: 5)
-      sd = state_dir || Session.default_state_dir
-      CONTINUE_TRIES.times do |try|
-        id = SessionChain.resolve(id_or_ref, state_dir: sd)
-        result = with_continue_lock(id, sd) do
-          follow = id_or_ref.to_s.strip.start_with?(SessionChain::LAST_PREFIX) && try < CONTINUE_TRIES - 1
-          next :moved if follow && SessionChain.next_of(id, state_dir: sd)
-
-          continue_locked(id, prompt: prompt, title: title, state_dir: sd, recap_wait: recap_wait,
-                              archive_wait: archive_wait)
-        end
-        return result unless result == :moved
-      end
-    end
-
-    private_class_method def self.with_continue_lock(id, state_dir, &)
-      dir = Session.session_dir(id, state_dir: state_dir)
-      FileUtils.mkdir_p(dir)
-      File.open(File.join(dir, CONTINUE_LOCK), File::RDWR | File::CREAT, 0o600) do |lock|
-        lock.flock(File::LOCK_EX)
-        yield
-      end
-    end
-
-    private_class_method def self.continue_locked(id, prompt:, title:, state_dir:, recap_wait:, archive_wait:)
-      previous = Session.load(id, state_dir: state_dir)
-      plan = check_continue!(previous, state_dir)
-      # archive_session's refusals that can be known now, before the wait.
-      archivable!(id, state_dir, except: plan.move)
-      recap_before_archive(id, state_dir, wait: recap_wait)
-      # Again: a turn sent to it during the wait may have delegated (they
-      # move too), or a delegate finished.
-      plan = move_plan!(id, state_dir)
-      already = [id, *descendant_ids(id, state_dir, except: plan.move)].select do |sid|
-        ArchiveStore.archived?(Session.session_dir(sid, state_dir: state_dir))
-      end
-      archived = archive_session(id, state_dir: state_dir, wait: archive_wait, except: plan.move)[:archived] - already
-      begin
-        spawn_continuation(previous, prompt: prompt, title: title, state_dir: state_dir, move: plan.move)
-      rescue StandardError
-        # Nothing started: the delegates go back, what this archived goes
-        # back to the lists, and a new link saved before its worker failed
-        # to spawn goes (left, it would hold the chain: "continued already",
-        # last: to it).
-        undo_move(id, state_dir, moved: plan.move)
-        begin
-          discard_failed_link(id, state_dir)
-        ensure
-          archived.each { |sid| ArchiveStore.unarchive(sid, state_dir: state_dir) }
-          wake_for_rings(id, state_dir) unless plan.move.empty?
-        end
-        raise
-      end
-    end
-
-    # The delegates a failed #continue_session moved, or began to (its
-    # intent names them), go back to +id+.
-    private_class_method def self.undo_move(id, state_dir, moved:)
-      link = SessionChain.next_of(id, state_dir: state_dir) or return
-      ids = ChildMove.read_intent(link, state_dir: state_dir)&.ids || moved
-      ChildMove.apply(ids, from: link, to: id, state_dir: state_dir, undo: true)
-      ChildMove.clear_intent(link, state_dir: state_dir)
-    rescue StandardError => e
-      Log.warn(:worker, "continue_undo_move_failed", sid: id, error: e.class.name, msg: e.message)
-    end
-
-    # The link a failed #continue_session saved (no other continues +id+:
-    # check_continue! made sure under the lock): its worker stopped if one
-    # started, then the rings a moved delegate wrote into it just before
-    # the undo go back to +id+, then the link goes. A worker that outlives
-    # the stop is raised (DeleteRefused): the link stays, and the caller
-    # hears it.
-    private_class_method def self.discard_failed_link(id, state_dir)
-      orphan = SessionChain.next_of(id, state_dir: state_dir) or return
-      if refuse_tui!(orphan, state_dir: state_dir) && !stop_session(orphan, state_dir: state_dir, wait: 10)
-        raise DeleteRefused.new(orphan, :still_stopping)
-      end
-
-      ChildMove.return_rings(from: orphan, to: id, state_dir: state_dir)
-      delete_session(orphan, state_dir: state_dir)
-    rescue DeleteRefused
-      raise
-    rescue StandardError => e
-      Log.warn(:worker, "continue_cleanup_failed", sid: id, error: e.class.name, msg: e.message)
-    end
-
-    # A failed continue's previous link, back in the lists, with rings that
-    # came in meanwhile: wake it for them, as the ring's own wake would have.
-    private_class_method def self.wake_for_rings(id, state_dir)
-      return if SessionInbox.find_ring_files(Session.session_dir(id, state_dir: state_dir)).empty?
-
-      wake_for_report(id, state_dir: state_dir)
-    rescue StandardError => e
-      Log.warn(:worker, "continue_wake_failed", sid: id, error: e.class.name, msg: e.message)
-    end
-
-    # The new link, holding off any worker but its own (ChildMove.starting?)
-    # while +move+ goes to it.
-    private_class_method def self.spawn_continuation(previous, prompt:, title:, state_dir:, move:)
-      recap = RecapStore.read(Session.session_dir(previous.id, state_dir: state_dir))
-      start = prompt.to_s.strip.empty? ? nil : prompt
-      title = previous.first_preview if title.to_s.strip.empty? && start.nil?
-      before_spawn = lambda do |link|
-        ChildMove.mark_starting(link.id, state_dir: state_dir)
-        ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
-      end
-      link = spawn_session(prompt: start, title: title, working_directory: previous.working_directory,
-                           model_name: previous.model_typed || previous.model_name, setup: SessionSetup.of(previous),
-                           continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
-                           note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn)
-      link.moved_children = move
-      link
-    end
-
-    # The refusals that come before anything changes: continued already (no
-    # forks in a chain), an open delegate that can't move to the new link
-    # (ChildMove.plan), the folder gone (the worker would run elsewhere), a
-    # model whose host config.yml no longer has.
-    # @return [ChildMove::Plan]
-    # @raise [ContinueRefused, ModelProfile::MissingModel]
-    private_class_method def self.check_continue!(previous, state_dir)
-      if (following = SessionChain.next_of(previous.id, state_dir: state_dir))
-        raise ContinueRefused.new(previous.id, :continued, ids: [following])
-      end
-
-      plan = move_plan!(previous.id, state_dir)
-      # Its model's host, as spawn_session checks it: before the archive
-      # stops the previous link's worker.
-      ModelProfile.check_host!(ModelProfile.required_model_name(previous.model_typed || previous.model_name))
-      dir = previous.working_directory.to_s
-      raise ContinueRefused.new(previous.id, :folder_gone, detail: dir) unless File.directory?(dir)
-
-      plan
-    end
-
-    # A child still open below a session (#open_children); why: running,
-    # waiting, live, unreported reply, or why it can't move (ChildMove).
-    OpenChild = Data.define(:id, :short_id, :why)
-
-    # The delegates a continue of +id+ moves (ChildMove.plan).
-    # @return [ChildMove::Plan]
-    # @raise [ContinueRefused] for open ones it can't move
-    private_class_method def self.move_plan!(id, state_dir)
-      plan = ChildMove.plan(id, open: open_children(id, state_dir), state_dir: state_dir)
-      return plan if plan.refuse.empty?
-
-      raise ContinueRefused.new(id, :open_children, ids: plan.refuse.map(&:id),
-                                                    detail: plan.refuse.map { |c| "#{c.short_id} (#{c.why})" }.join(", "))
-    end
-
-    # The unarchived children, at any depth (the archive's cascade), of the
-    # session still running, waiting for an answer, with a live worker, or
-    # (a delegate) with a reply its parent wasn't given (ChildrenStatus).
-    # @return [Array<OpenChild>]
-    def self.open_children(id, state_dir)
-      require_relative "children_status"
-      [id, *descendant_ids(id, state_dir)].flat_map { |node| ChildrenStatus.of(node, state_dir: state_dir) }.uniq(&:id)
-                                          .filter_map do |child|
-        why = if %w[waiting running].include?(child.state) then child.state
-              elsif child.live then "live"
-              elsif child.delegate && child.last_reply && !child.reported then "unreported reply"
-              end
-        why && OpenChild.new(id: child.id, short_id: child.short_id, why: why)
-      end
-    end
-
-    # Ask the session's live worker for a recap now (Bridge POST /recap:
-    # IdleRecap#request_now) and wait, up to +wait+ seconds, for recap.json
-    # to change. A worker that is gone wrote its recap when it left; one
-    # that has nothing new to say, too short a conversation, or recaps off
-    # answers at once. Best effort: the continue goes on without.
-    private_class_method def self.recap_before_archive(id, state_dir, wait:)
-      return unless worker_live?(id, state_dir: state_dir)
-
-      dir = Session.session_dir(id, state_dir: state_dir)
-      client = BridgeClient.discover(id, session_dir: dir) or return
-      before = RecapStore.read(dir)
-      reply = client.request_recap
-      asked = reply.status == 200 && reply.json.is_a?(Hash) ? reply.json["request"] : nil
-      return unless %w[started in_flight].include?(asked)
-
-      BridgeClient.poll(wait, interval: 0.2) { RecapStore.read(dir) != before }
-    rescue StandardError => e
-      Log.info(:worker, "continue_recap_failed", sid: id, error: e.class.name, msg: e.message)
-      nil
-    end
+    # Start the next link of a chain (SessionContinue.run, which has the
+    # rules and raises SessionContinue::Refused).
+    def self.continue_session(...) = SessionContinue.run(...)
 
     # Build the opts hash passed to Process.spawn for a forked worker. The
     # child inherits this process's ENV and reads config.yml itself (as it
@@ -636,10 +392,11 @@ module Samagotchi
     end
 
     # The session and its descendants, with their owners, when they can be
-    # archived now (#archive_refusal for each), else the refusal.
+    # archived now (#archive_refusal for each), else the refusal. Public for
+    # SessionContinue, which checks before its recap wait.
     # @return [Array(Array<String>, Hash)] the ids, and id => OwnerLock::Owner or nil
     # @raise [ArchiveRefused, OwnedByTUI]
-    private_class_method def self.archivable!(id, state_dir, except: [])
+    def self.archivable!(id, state_dir, except: [])
       raise ArchiveRefused.new(id, :scratch) if Session.load(id, state_dir: state_dir).scratch
 
       tree = [id, *descendant_ids(id, state_dir, except: except)]
@@ -974,7 +731,7 @@ module Samagotchi
     # 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_SKELETON_FILES = ["pid", "owner.lock", WorkerSidecar::FILE, AnalyticsFile::NAME].freeze
     EMPTY_DIRS = [SessionInbox::INPUT_DIR, SessionInbox::NOTES_DIR, "images"].freeze
     EMPTY_SKELETON_DIRS = (EMPTY_DIRS + [SessionInbox::OUTPUT_DIR]).freeze
 
@@ -1058,17 +815,48 @@ module Samagotchi
         path = File.join(dir, name)
         if EMPTY_SKELETON_DIRS.include?(name)
           File.directory?(path) && (!EMPTY_DIRS.include?(name) || Dir.empty?(path))
-        elsif name == "analytics.json"
-          Array(JSON.parse(File.read(path))["turn_records"]).empty?
+        elsif name == AnalyticsFile::NAME
+          analytics_empty?(path)
         # Cards and notices from before any turn (Bridge::CardStore).
         elsif name == "cards.json"
-          JSON.parse(File.read(path))["turns"].to_i.zero?
+          cards_empty?(path)
         else
           EMPTY_SKELETON_FILES.include?(name)
         end
       end
     end
 
+    # A folder's analytics.json is empty only when it is a JSON object with
+    # an empty turn_records array. Anything unreadable, not JSON, not an
+    # object, the wrong type, or turn_records the wrong shape reads as
+    # "not empty": a broken analytics keeps the folder instead of crashing
+    # the retention sweep (or of a wrong-shape one reading as empty).
+    def self.analytics_empty?(path)
+      data = read_json(path)
+      turns = data.is_a?(Hash) ? data["turn_records"] : nil
+      turns.is_a?(Array) && turns.empty?
+    end
+
+    # A folder's cards.json is empty only when it is a JSON object whose
+    # turns is an integer zero. Anything unreadable, not JSON, not an
+    # object, the wrong type, or turns not an integer reads as "not empty":
+    # a broken or wrong-shape cards file keeps the folder instead of
+    # raising (Array#/Hash#to_i) or reading as empty.
+    def self.cards_empty?(path)
+      data = read_json(path)
+      turns = data.is_a?(Hash) ? data["turns"] : nil
+      turns.is_a?(Integer) && turns.zero?
+    end
+
+    # A session-dir JSON file's contents, or nil when it is missing,
+    # unreadable, not JSON or not an object (mirrors AnalyticsFile#read): a
+    # broken file reads as none, so its folder is kept, not deleted.
+    def self.read_json(path)
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
     # Delete one session: its <id>.json, the whole <id>/ directory
     # (history sidecars, input, output, notes, images) and its attached
     # context (ContextSources: its sources, subscriptions, mute markers). The CLI, the TUI's

data/lib/samagotchi/session_metrics.rb

@@ -5,6 +5,7 @@ require "monitor"
 require "time"
 require "fileutils"
 require "securerandom"
+require_relative "analytics_file"
 require_relative "atomic_file"
 require_relative "token_usage"
 require_relative "model_price"
@@ -172,8 +173,8 @@ module Samagotchi
     # @param budget_tokens [Integer, Proc, nil] see .saved_context_pct
     # @return [SavedSummary, nil]
     def self.saved_summary(session_dir, budget_tokens: nil)
-      data = JSON.parse(File.read(File.join(session_dir, "analytics.json")))
-      return nil unless data.is_a?(Hash)
+      data = AnalyticsFile.read(session_dir)
+      return nil unless data
 
       tokens = data["tokens"].is_a?(Hash) ? data["tokens"] : {}
       count = ->(key) { tokens[key].is_a?(Numeric) ? tokens[key] : 0 }
@@ -182,7 +183,7 @@ module Samagotchi
                        reasoning_sum: count.call("reasoning_sum"), cost_sum: count.call("cost_sum"),
                        cost_estimate_sum: count.call("cost_estimate_sum"),
                        memory_index: data["memory_index"].is_a?(Hash) ? data["memory_index"] : nil)
-    rescue JSON::ParserError, SystemCallError, TypeError
+    rescue TypeError
       nil
     end
 
@@ -217,10 +218,10 @@ module Samagotchi
     def self.saved_tool_records(session_dir, turn_id)
       return [] if turn_id.to_s.empty?
 
-      records = JSON.parse(File.read(File.join(session_dir, "analytics.json")))["tool_records"]
+      records = AnalyticsFile.read(session_dir)&.dig("tool_records")
       Array(records).select { |r| r.is_a?(Hash) && r["turn_id"] == turn_id }
                     .sort_by { |r| [r["iteration"].to_i, r["call_index"].to_i] }
-    rescue JSON::ParserError, SystemCallError, TypeError
+    rescue TypeError
       []
     end
 
@@ -234,9 +235,9 @@ module Samagotchi
     def self.saved_turn_record(session_dir, turn_id)
       return nil if turn_id.to_s.empty?
 
-      records = JSON.parse(File.read(File.join(session_dir, "analytics.json")))["turn_records"]
+      records = AnalyticsFile.read(session_dir)&.dig("turn_records")
       Array(records).find { |r| r.is_a?(Hash) && r["id"] == turn_id }
-    rescue JSON::ParserError, SystemCallError, TypeError
+    rescue TypeError
       nil
     end
 
@@ -422,8 +423,7 @@ module Samagotchi
       # (XDG) location; passing an explicit nil would override it and break
       # File.join.
       FileUtils.mkdir_p(dir = session_dir(sid, state_dir || @state_dir))
-      path = File.join(dir, "analytics.json")
-      AtomicFile.write(path, JSON.pretty_generate(data) + "\n")
+      AtomicFile.write(AnalyticsFile.path(dir), JSON.pretty_generate(data) + "\n")
       @mutex.synchronize { @persisted_turns = [@persisted_turns, turn_count].max }
       true
     rescue StandardError
@@ -824,6 +824,8 @@ module Samagotchi
 
         called_as = event.dig(:activity, :called_as)
         active[:called_as] = called_as.to_s if called_as
+        # A grep that found nothing (ok): the reloaded web row says "no match".
+        active[:no_match] = true if event.dig(:activity, :no_match)
         finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i)
       end
     end
@@ -831,7 +833,7 @@ module Samagotchi
     # Caller holds the mutex.
     def finish_tool_record(active, status, waited_ms: 0)
       record = active.slice(
-        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :started_at
+        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :no_match, :started_at
       ).merge(
         status: status,
         completed_at: now.iso8601(3),
@@ -977,11 +979,8 @@ module Samagotchi
     # broken file, or an older shape: nothing, or zeros where keys are
     # missing). Caller holds the mutex.
     def load_persisted
-      path = File.join(session_dir(@session_id, @state_dir), "analytics.json")
-      return unless File.file?(path)
-
-      prior = JSON.parse(File.read(path))
-      return unless prior.is_a?(Hash)
+      prior = AnalyticsFile.read(session_dir(@session_id, @state_dir))
+      return unless prior
 
       loaded_turns = loaded_records(prior["turn_records"])
       @turn_records = loaded_turns + @turn_records
@@ -1004,12 +1003,10 @@ module Samagotchi
       @memory_index ||= symbolized(prior["memory_index"]) if prior["memory_index"].is_a?(Hash)
       # The window last seen, until this process's first generation reports.
       window = prior["context"].is_a?(Hash) ? prior["context"] : {}
-      if window["window_tokens"] && @context_window_tokens.nil?
-        @context_window_tokens = window["window_tokens"]
-        @context_window_source = window["window_source"]
-      end
-    rescue JSON::ParserError, SystemCallError
-      nil
+      return unless window["window_tokens"] && @context_window_tokens.nil?
+
+      @context_window_tokens = window["window_tokens"]
+      @context_window_source = window["window_source"]
     end
 
     def symbolized(hash)

data/lib/samagotchi/sessions_command.rb

@@ -5,6 +5,7 @@ require_relative "session"
 require_relative "session_manager"
 require_relative "session_retention"
 require_relative "project_scope"
+require_relative "analytics_file"
 require_relative "session_metrics"
 require_relative "recap_store"
 require_relative "session_delete_command"
@@ -337,10 +338,10 @@ module Samagotchi
           return [TerminalUI::EventRenderer.deep_symbolize_keys(body), true, nil]
         end
       end
-      return [nil, false, nil] unless File.file?(File.join(dir, "analytics.json"))
+      return [nil, false, nil] unless File.file?(Samagotchi::AnalyticsFile.path(dir))
 
       snapshot = Samagotchi::SessionMetrics.new.tap { |m| m.session_id = session.id }.saved_snapshot
-      note = live_worker?(session.id) ? "(no live worker answered; from the saved analytics.json)" : nil
+      note = live_worker?(session.id) ? "(no live worker answered; from the saved #{Samagotchi::AnalyticsFile::NAME})" : nil
       [snapshot, false, note]
     end
 

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -1268,7 +1268,8 @@ module Samagotchi
       # (it ended first).
       def join_tool_line(part, duration_ms: nil)
         output = part[:output]
-        status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool])
+        command = part.dig(:view, :truncated) ? nil : part.dig(:view, :command)
+        status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool], command: command)
         activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
                      params: part[:params], status: status,
                      description: ToolView.description_title(part[:view] || {}) }

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -20,7 +20,7 @@ module Samagotchi
       # (no UI: the same text from the CLI).
       # @return [String] "(no metrics yet)" without a snapshot
       def self.format_session_metrics(snapshot)
-        (@formatter ||= Object.new.extend(Formatting)).send(:format_session_metrics, snapshot)
+        (@formatter ||= Object.new.extend(Formatting)).format_session_metrics(snapshot)
       end
 
       def format_tool_activity_line(activity, duration_ms: nil)
@@ -543,6 +543,8 @@ module Samagotchi
         value.length > width ? value[0, width] : value
       end
 
+      public
+
       # Render the analytics snapshot as a compact, user-facing report. Raw event
       # logs (debug-only) are intentionally excluded; this surface is for the REPL
       # and `chi sessions stats` (the module function above).
@@ -607,6 +609,8 @@ module Samagotchi
         lines.join("\n")
       end
 
+      private
+
       # " (25.0% of the 64000 budget)" when the session's llm_context budget
       # is set and smaller than the window, else " (12.5%)": the live meter
       # counts against the smaller of the two (ContextStatus#counted_against),

data/lib/samagotchi/terminal_ui.rb

@@ -238,6 +238,10 @@ module Samagotchi
       # --non-interactive with no --prompt is a harmless no-op exit: build
       # nothing and return (no transient session, no banner).
       return if @non_interactive && @prompt.nil?
+      # A UI-only command (/stats, /exit …) isn't run without the REPL, and
+      # isn't a prompt either: refused as chi send refuses it, before any
+      # session is made (bin/chi exits 1).
+      return refuse_one_shot_ui_command if @non_interactive && SessionCommands.ui_only_entry(@prompt)
 
       session = @resume_session || @engine.store_model!(Session.new_session(
         mode: "assist",
@@ -269,6 +273,16 @@ module Samagotchi
       return run_one_shot_command(session) if @prompt && @non_interactive && command_registry.command?(@prompt)
 
       if @prompt && @non_interactive
+        # A /cut TEXT / /queue TEXT prompt runs its text as the turn's
+        # prompt, the same as the idle REPL does (Formatting#steer_choice);
+        # a bare /cut / /queue (no text) is refused above as a UI command,
+        # so only the text here. The images are the text's, not the words'.
+        one_shot_prompt =
+          if (choice = steer_choice(@prompt)) && !choice.last.empty?
+            choice.last
+          else
+            @prompt
+          end
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
         # Retry lines and hook notices on stderr; stdout gets the answer below.
@@ -277,11 +291,11 @@ module Samagotchi
         begin
           result = @engine.run_turn(
             session,
-            @prompt,
+            one_shot_prompt,
             on_event: sink,
             max_iterations: IterationLimit.for(no_interrupt: true),
             cancel_controller: nil,
-            images: ImageInput.extract(@prompt)
+            images: ImageInput.extract(one_shot_prompt)
           )
         rescue LLM::ProviderError, ImageStore::Error => e
           return one_shot_failed(session, e)
@@ -348,7 +362,7 @@ module Samagotchi
     # so the session is kept and `chi --resume` takes it up again.
     # @return [Symbol] :turn_failed
     def one_shot_failed(session, error)
-      warn "Error: #{error.respond_to?(:summary) ? error.summary : error.message}"
+      warn "Error: #{@engine.failure_summary(error)}"
       if !@scratch && Session.exist?(session.id)
         warn "chi: the session is kept with your prompt; continue it with: chi --resume #{session.id}"
       end
@@ -371,6 +385,14 @@ module Samagotchi
       :turn_failed if result.status == :error
     end
 
+    # `chi -p /stats --non-interactive`: why it doesn't run, on stderr.
+    # @return [Symbol] :turn_failed
+    def refuse_one_shot_ui_command
+      name = SessionCommands.ui_only_entry(@prompt).name
+      warn "chi: refused: #{SessionCommands.ui_only_refusal(name, @resume_session&.id, runner: "--non-interactive")}"
+      :turn_failed
+    end
+
     # Ctrl-C in a -p --non-interactive turn: the Engine kept the prompt and
     # a cancel note in the session (it saves only a failed turn), so save
     # it here: `chi --resume` takes it up again. A scratch session goes in