samagotchi 0.4.0 → 0.5.0

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -4,6 +4,7 @@ require "set"
 require_relative "event_renderer"
 require_relative "formatting"
 require_relative "attached_view"
+require_relative "status_row"
 require_relative "input_support"
 require_relative "image_input"
 require_relative "line_reader"
@@ -45,7 +46,6 @@ module Samagotchi
         "continue_offered" => "a continue offer is pending", "client_connected" => "another UI is attached",
         "reminders" => "reminders are set", "starting" => "the worker is still starting"
       }.freeze
-      ROLLBACK_HINT = "partial progress kept in context; !rollback restores the pre-turn state"
       # How much of the last answer a join shows.
       JOIN_ANSWER_LINES = 12
       JOIN_ANSWER_CHARS = 1200
@@ -57,7 +57,8 @@ module Samagotchi
 
       # @return [String, nil] the model the worker's turns run on, as the
       #   last command said
-      attr_reader :model_name
+      # @return [String, nil] the worker's model
+      def model_name = @status[:model]
 
       # @return [QuestionPrompt, nil] the question waiting for an answer
       attr_reader :question
@@ -77,8 +78,12 @@ module Samagotchi
       # @param delete_session [#call] session id -> deletes it (/exit --delete)
       # @param archive_session [#call] session id -> archives it (/archive);
       #   SessionManager.archive_session's result
+      # @param wait_at_eof [Boolean] lines come from a pipe or a file (`chi -p
+      #   X </dev/null`): at their end, detach only once this run's prompts
+      #   (the -p one too) have had their turns; if one failed, #run says so
       def initialize(client:, screen:, client_id:, first_prompt: nil, first_command: nil, no_interrupt: false,
-                     default_input: false, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
+                     default_input: false, wait_at_eof: false,
+                     clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
                      delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: DELETE_WAIT) },
                      archive_session: ->(id) { SessionManager.archive_session(id, wait: DELETE_WAIT) })
         @client = client
@@ -106,20 +111,18 @@ module Samagotchi
         # Prompts this run sent, by enqueued_id: only those come back into
         # the input when their turn fails (a replayed event must not).
         @sent_ids = Set.new
+        @wait_at_eof = wait_at_eof
+        # Sent and not ended yet (by enqueued_id), the ones merged into the
+        # running turn, whether the input has ended, and whether one of this
+        # run's prompts failed (wait_at_eof only).
+        @open_ids = Set.new
+        @merged_ids = Set.new
+        @input_ended = false
+        @own_failed = false
         # A continue offer is pending: the prompt asks for the answer.
         @continue_offer = nil
-        @model_name = nil
-        @turn_continues = false
-        # The idle status line's data (the REPL's segments).
-        @memory_names = []
-        # The session's --memory list (shown with the used memories until the
-        # first turn records them) and its --mute list, from the join.
-        @preloaded_names = []
-        @muted_names = []
-        # The session that delegated this one, shown as ↳ <short id>.
-        @parent_id = nil
-        @context_estimate = nil
-        @status_rows = nil
+        # The status row: the worker's model, ctx, the session's memories.
+        @status = StatusRow.new(screen)
       end
 
       def running? = @running
@@ -127,8 +130,10 @@ module Samagotchi
       # Follow the session and read input until Ctrl-D, /detach, /exit or
       # the worker goes away. The worker keeps running after a detach; /exit
       # asks it to exit too, and it does unless something still needs it.
-      # @return [Symbol] :detached, :closed when the worker went away, or
-      #   :failed when the first command (--model) didn't go through
+      # @return [Symbol] :detached, :closed when the worker went away,
+      #   :failed when the first command (--model) didn't go through, or
+      #   (wait_at_eof) :turn_failed when one of this run's prompts failed and
+      #   :unanswered when a question came after the input ended
       # @param input [#call, nil] prompt -> line (nil = Ctrl-D, raising
       #   Interrupt = Ctrl-C); defaults to Reline
       def run(input: nil)
@@ -148,8 +153,17 @@ module Samagotchi
           case kind
           when :event
             ended = safely_handle(payload)
-            return ended if ended == :closed || ended == :failed
-          when :line then return :detached if submit(payload) == :detach
+            return ended if %i[closed failed unanswered].include?(ended)
+            return end_of_input if @input_ended && !own_turns_pending?
+          when :line
+            if payload.nil? && @wait_at_eof && own_turns_pending?
+              # The pipe's end: this run's turns first. An open question
+              # has nothing left to answer it.
+              return unanswered_question if @question
+
+              next @input_ended = true
+            end
+            return end_of_input if submit(payload) == :detach
           when :interrupt then return :detached if interrupt(payload) == :detach
           end
         end
@@ -176,22 +190,19 @@ module Samagotchi
           return render_snapshot(event[:snapshot] || {}, reset: event[:type] == :reset)
         when :turn_enqueued then show_enqueued(event)
         when :turn_started then start_turn(event)
-        when :turn_completed then complete_turn(event)
-        when :turn_canceled
-          continued = @turn_continues
-          end_turn("turn cancelled (#{event[:cancellation_reason]})")
-          # A cancelled continue is back where it started; a prompt turn's
-          # partial progress stays, as in the REPL.
-          @screen.commit(ROLLBACK_HINT) unless continued
-        when :turn_failed
-          end_turn("turn failed: #{event[:summary] || "#{event[:message]} (#{event[:error_class]})"}")
+        when :turn_completed
+          complete_turn(event)
+          own_turn_ended(event)
+        # The renderer says how it ended (the REPL's words too).
+        when :turn_canceled, :turn_failed
+          @renderer.call(event)
+          end_turn
+          own_turn_ended(event)
         when :prompt_restored then restore_prompt(event)
         when :context_status
-          @context_estimate = { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] }
-          refresh_status
+          @status.update(context: { est_pct: event.dig(:usage, :estimated_pct), bucket: event[:bucket] })
         when :used_memories_updated
-          @memory_names = Array(event[:used_memory_names])
-          refresh_status
+          @status.update(used_memories: Array(event[:used_memory_names]))
         # Another client's anytime command: its line now, before the cards
         # it shows (its command_ran comes when it's done).
         when :command_queued
@@ -207,8 +218,12 @@ module Samagotchi
         when :continue_resolved then continue_resolved(event)
         # The note comes with the kernel's :pending_input_merged (EventRenderer),
         # after the answer the merge follows.
-        when :input_merged then nil
-        when :question_requested then ask(event[:pending_question])
+        when :input_merged then merged_own_prompts(event)
+        when :question_requested
+          # Nothing is left to answer it with.
+          return unanswered_question if @input_ended
+
+          ask(event[:pending_question])
         when :question_answered then question_answered(event)
         when :question_cancelled
           close_question("(question cancelled)") if @question
@@ -434,9 +449,8 @@ module Samagotchi
         return unless event[:model_name]
 
         # After the output, so the status row changes with the line saying why.
-        @served_model = nil if @model_name != event[:model_name]
-        @model_name = event[:model_name]
-        refresh_status
+        served = @status[:model] == event[:model_name] ? @status[:served] : nil
+        @status.update(model: event[:model_name], default_model: default_model_name, served: served)
       end
 
       # Our command the worker couldn't run yet goes back into the prompt, for
@@ -490,7 +504,7 @@ module Samagotchi
       def send_prompt(text)
         persist_recent_history(text)
         images = attach_images(text)
-        return if images.nil?
+        return own_prompt_failed if images.nil?
 
         options = { prompt: text, client_id: @client_id }
         options[:no_interrupt] = true if @no_interrupt
@@ -499,9 +513,12 @@ module Samagotchi
         if reply.status == 202
           enqueued_id = reply.json&.fetch("enqueued_id", nil)
           @sent_ids << enqueued_id if enqueued_id
+          @open_ids << enqueued_id if enqueued_id && @wait_at_eof
           return
         end
 
+        own_prompt_failed
+
         detail = reply.json&.fetch("error", nil)
         # Read after its deadline and dropped (BridgeClient::DEADLINE_SHARE).
         return @screen.commit("could not send the prompt (#{LATE})") if detail == "deadline_passed"
@@ -509,9 +526,51 @@ module Samagotchi
         explained = reply.json&.fetch("detail", nil) if detail == "images_unsupported"
         @screen.commit("could not send the prompt (#{[reply.status, detail].compact.join(" ")})#{": #{explained}" if explained}")
       rescue SystemCallError, IOError => e
+        own_prompt_failed
         @screen.commit("could not send the prompt (#{worker_down(e)})")
       end
 
+      # Whether the input's end must wait: the -p prompt isn't sent yet, or
+      # a prompt this run sent hasn't had its turn.
+      def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty?
+
+      # A turn ended: this run's prompt (and ours merged into it) had its turn.
+      def own_turn_ended(event)
+        return unless @wait_at_eof
+
+        id = (event[:origin] || {})[:enqueued_id]
+        ours = @open_ids.include?(id) || !@merged_ids.empty?
+        @own_failed = true if ours && event[:type] == :turn_failed
+        @open_ids.delete(id)
+        @open_ids.subtract(@merged_ids)
+        @merged_ids.clear
+      end
+
+      # Ours merged into the running turn: they end with it.
+      def merged_own_prompts(event)
+        Array(event[:origins]).each do |origin|
+          id = origin[:enqueued_id]
+          @merged_ids << id if own?(origin[:client_id]) && @open_ids.include?(id)
+        end
+        nil
+      end
+
+      def own_prompt_failed
+        @own_failed = true if @wait_at_eof
+        nil
+      end
+
+      # The input ended and nothing of ours is left to wait for.
+      def end_of_input
+        detach("Detached; the session keeps running. Re-attach with: chi --attach #{@client.session_id}") if @input_ended
+        @own_failed ? :turn_failed : :detached
+      end
+
+      def unanswered_question
+        detach("A question waits for an answer: chi --attach #{@client.session_id}")
+        :unanswered
+      end
+
       # The prompt's `@path` images, stored in the session's images/ here
       # (this machine, the worker's state dir) and sent as refs: the Bridge
       # never takes a path. nil (after a line saying why) when one can't be.
@@ -657,11 +716,13 @@ module Samagotchi
       def restore_prompt(event)
         origin = event[:origin] || {}
         return unless own?(origin[:client_id]) && @sent_ids.include?(origin[:enqueued_id])
+        # Lines from a pipe: nobody to retry it (the REPL's rule).
+        return if @wait_at_eof
 
         if @reader&.prefill(event[:prompt].to_s)
-          @screen.commit("(prompt restored for retry)")
+          @screen.commit(turn_end_hint("prompt restored for retry"))
         else
-          @screen.commit("(the failed prompt is in the input history: ↑)")
+          @screen.commit(turn_end_hint("the failed prompt is in the input history (↑)"))
         end
       end
 
@@ -903,8 +964,9 @@ module Samagotchi
         @joined_mid_turn = @running
         return unless turn
 
-        @turn_continues = turn[:prompt].nil?
-        unless @turn_continues && reminder_origin?(turn[:origin] || {})
+        continues = turn[:prompt].nil?
+        @renderer.turn_continues = continues
+        unless continues && reminder_origin?(turn[:origin] || {})
           @screen.commit(prompt_line(turn.dig(:origin, :client_id), turn[:prompt] || "(continuing)"))
         end
         Array(turn[:images]).each { |ref| @screen.commit(format_image_line(ref)) }
@@ -941,9 +1003,8 @@ module Samagotchi
       def start_turn(event)
         @running = true
         @joined_mid_turn = false
-        @turn_continues = event[:prompt].nil?
         origin = event[:origin] || {}
-        if @turn_continues
+        if event[:prompt].nil?
           # A continue turn (after the offer's yes) has no prompt to show; a
           # reminder turn shows its reminders (:reminder_injected).
           @screen.commit(prompt_line(origin[:client_id], "(continuing)")) unless reminder_origin?(origin)
@@ -961,16 +1022,13 @@ module Samagotchi
         end
         @renderer.call(event)
         # The turn's summary carries its last context estimate.
-        @context_estimate = @view.context_status if @view.context_status
-        refresh_status
+        @status.update(context: @view.context_status) if @view.context_status
         @running = false
         @joined_mid_turn = false
         close_question("(the turn ended)") if @question
       end
 
-      def end_turn(message)
-        @view.finish_thinking_spinner
-        @screen.commit(message)
+      def end_turn
         @running = false
         @joined_mid_turn = false
         close_question("(the turn ended)") if @question
@@ -981,43 +1039,22 @@ module Samagotchi
       # The joining snapshot's session state: the worker's model and the
       # memories the session used.
       def take_session_state(state)
-        @model_name = state[:model_name] if state[:model_name]
-        @served_model = nil
-        take_served_model(state[:served_model], state[:served_model_for], refresh: false)
-        @memory_names = Array(state[:used_memory_names]) if state.key?(:used_memory_names)
-        @preloaded_names = Array(state[:preloaded_memory_names]) if state.key?(:preloaded_memory_names)
-        @muted_names = Array(state[:muted_memory_names]) if state.key?(:muted_memory_names)
-        @parent_id = state[:parent_id] if state.key?(:parent_id)
+        fields = { served: nil }
+        fields.merge!(model: state[:model_name], default_model: default_model_name) if state[:model_name]
+        fields[:served] = [state[:served_model], state[:served_model_for]] if state[:served_model]
+        fields[:used_memories] = Array(state[:used_memory_names]) if state.key?(:used_memory_names)
+        fields[:preloaded] = Array(state[:preloaded_memory_names]) if state.key?(:preloaded_memory_names)
+        fields[:muted] = Array(state[:muted_memory_names]) if state.key?(:muted_memory_names)
+        fields[:parent_id] = state[:parent_id] if state.key?(:parent_id)
         # The last turn's ctx, so it shows before this client's first turn.
-        @context_estimate = state[:context_status] if state[:context_status].is_a?(Hash)
-        refresh_status
+        fields[:context] = state[:context_status] if state[:context_status].is_a?(Hash)
+        @status.update(**fields)
       end
 
-      # The REPL's idle status line (model · ctx · memories) in the status
-      # row, redrawn when its text changes.
-      def refresh_status
-        return unless status_line_enabled?
-
-        served, served_for = @served_model
-        segments = [@model_name ? status_model_text(@model_name, default_model_name, served: served, served_for: served_for) : "",
-                    @parent_id ? "↳ #{@parent_id.to_s[0, 8]}" : "",
-                    status_context_text(estimate: @context_estimate),
-                    status_memory_text(@memory_names | @preloaded_names, MEMORY_STICKY_PREVIEW_LIMIT),
-                    status_memory_text(@muted_names, MEMORY_STICKY_PREVIEW_LIMIT, label: "muted")].reject(&:empty?)
-        rows = status_rows(segments, @screen.columns - 1)
-        return if rows == @status_rows
-
-        @status_rows = rows
-        rows.empty? ? @screen.clear_slot(:status) : @screen.set_slot(:status, rows)
-      end
-
-      # What the worker's server said it served for a name (a generation, or
-      # the join's session state); dropped when /model switches.
-      def take_served_model(served, served_for, refresh: true)
-        return unless served
-
-        @served_model = [served, served_for]
-        refresh_status if refresh
+      # What the worker's server said it served for a name (a generation);
+      # dropped when /model switches.
+      def take_served_model(served, served_for)
+        @status.update(served: [served, served_for]) if served
       end
 
       # The config's default model, as the worker's /model names it.

data/lib/samagotchi/terminal_ui/attached_view.rb

@@ -8,13 +8,12 @@ require_relative "thinking_line"
 
 module Samagotchi
   class TerminalUI
-    # EventRenderer's view in attached mode, drawn on a Screen: the
-    # thinking feedback is the activity slot, one row right above the prompt
-    # (spinner frame, then the running tool or the newest sentence of the
-    # model's thinking or text, ThinkingLine),
-    # and every finished line is committed output. The local REPL's
-    # multi-line spinner redraws in place, which can't share the terminal
-    # with an open prompt.
+    # EventRenderer's view in both TUIs (attached mode and the REPL), drawn
+    # on a Screen: the thinking feedback is the activity slot, one row right
+    # above the prompt (spinner frame, then the running tool or the newest
+    # sentence of the model's thinking or text, ThinkingLine), and every
+    # finished line is committed output. On a PlainSurface the activity
+    # slot is dropped.
     #
     # The spinner turns with time, not per chunk: while the slot is shown a
     # ticker thread redraws it every TICK_INTERVAL, so a turn that gets no
@@ -59,6 +58,16 @@ module Samagotchi
         @screen.commit(text)
       end
 
+      # Draw on +surface+ from now on (the REPL swaps in its live region
+      # after the view is built, and back when it ends): what the slot shows
+      # moves there.
+      def surface=(surface)
+        @lock.synchronize do
+          @screen = surface
+          redraw_status if status_text
+        end
+      end
+
       # A new turn: its tally starts over too.
       def reset_turn_feedback
         @lock.synchronize do
@@ -81,7 +90,7 @@ module Samagotchi
 
       def generation_feedback_retrying(event)
         @lock.synchronize do
-          @retry = "retrying (attempt #{event[:attempt]})"
+          @retry = retry_text(event)
           # The retry streams from the start: wait for its first token again.
           @waiting_since = @clock.call if @thinking
           redraw_status
@@ -194,9 +203,6 @@ module Samagotchi
         @context_status = status if status
       end
 
-      # The REPL's sticky memories line has no source in attached mode.
-      def emit_active_memories_line; end
-
       private
 
       def reset_feedback_state
@@ -207,6 +213,15 @@ module Samagotchi
         @waiting_since = nil
       end
 
+      # "retrying (1/4 in 0.5s): Errno::ECONNREFUSED": the attempt of all
+      # there will be, the wait before it, and what failed.
+      def retry_text(event)
+        return "retrying (attempt #{event[:attempt]})" unless event[:max_retries]
+
+        text = "retrying (#{event[:attempt]}/#{event[:max_retries].to_i + 1} in #{format("%.1f", event[:next_delay].to_f)}s)"
+        event[:error_class].to_s.empty? ? text : "#{text}: #{event[:error_class]}"
+      end
+
       def tally_key(event)
         [event[:iteration].to_i, event[:call_index].to_i]
       end
@@ -246,7 +261,7 @@ module Samagotchi
       def status_text
         now = @clock.call
         frame = FRAMES[((now - @origin) / FRAME_INTERVAL).floor % FRAMES.length]
-        return "#{frame} #{@retry}" if @retry
+        return "#{frame} #{paint(@retry, 90)}" if @retry
         return "#{frame} #{@tool}…" if @tool
         return "#{frame} #{@init_tasks.values.join(" · ")}…" if !@thinking && @init_tasks.any?
         return nil unless @thinking

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 require "set"
+require_relative "formatting"
 
 module Samagotchi
   class TerminalUI
     # Renders one UI's view of Engine turn events: the thinking spinner while
     # the model generates, a `tool>` line per completed tool call, and the
     # answer (with any tool activity not already shown) from :turn_completed's
-    # turn_summary. It is the `on_event:` sink the REPL hands Engine#run_turn.
+    # turn_summary, and how a turn ended. It is the `on_event:` sink the REPL
+    # hands Engine#run_turn, and renders what attached mode gets over the
+    # Bridge.
     #
-    # Drawing is delegated to a +view+ (the TerminalUI), so the same dispatch
-    # can later render events that arrive over the Bridge. The renderer keeps
+    # Drawing is delegated to a +view+ (an AttachedView in both TUIs). The
+    # renderer keeps
     # only per-turn bookkeeping that must come from the events themselves:
     # which tool lines were already streamed, and when each tool call started.
     # Events that came over the Bridge as JSON (string keys) are symbolized first.
@@ -22,8 +25,14 @@ module Samagotchi
         @tool_started_at = {}
         # Card ids shown so far (across turns): one shown again is updated.
         @card_ids = Set.new
+        @turn_continues = false
       end
 
+      # Whether the running turn continues an earlier one (a continue or a
+      # reminder turn): set from :turn_started, or by a UI that joined the
+      # turn mid-way. A canceled one gets no rollback hint.
+      attr_writer :turn_continues
+
       # Deep-convert a string-keyed event (JSON from the Bridge) to the local
       # shape: symbol keys and a symbol :type. Other values stay as they are.
       def self.symbolize(event)
@@ -45,6 +54,7 @@ module Samagotchi
         case event[:type]
         when :turn_started
           begin_turn
+          @turn_continues = event[:continue] ? true : event[:prompt].nil?
           Array(event[:images]).each { |ref| @view.print_line(@view.format_image_line(ref)) }
         when :generation_started
           @view.generation_feedback_started(event)
@@ -55,8 +65,6 @@ module Samagotchi
         when :tool_call_started
           @tool_started_at[tool_call_key(event)] = @clock.call
           @view.tool_call_feedback_started(event)
-        when :used_memories_updated
-          @view.used_memories_updated(event) if @view.respond_to?(:used_memories_updated)
         when :tool_call_completed
           @view.clear_generation_retry
           @view.tool_call_feedback_completed(event)
@@ -71,6 +79,15 @@ module Samagotchi
           @view.print_line(@view.format_empty_retry_line(event))
         when :turn_completed
           render_turn_summary(event[:turn_summary]) if event[:turn_summary]
+        when :turn_canceled
+          @view.finish_thinking_spinner
+          @view.print_line(@view.turn_canceled_line(event[:cancellation_reason], event[:duration_ms]))
+          @view.print_line(@view.turn_end_hint(Formatting::ROLLBACK_HINT)) unless @turn_continues
+        when :turn_failed
+          # A provider error's one-line summary, else the message (an image
+          # that couldn't be used).
+          @view.finish_thinking_spinner
+          @view.print_line(@view.turn_failed_line(event[:summary] || event[:message], event[:duration_ms]))
         when :guardrail_warning
           @view.print_line(self.class.load_warning_line(event))
         when :hook_notice
@@ -138,7 +155,7 @@ module Samagotchi
       end
 
       # Render a finished turn: tool activity the stream did not already show,
-      # the status lines, the answer, and the iteration-limit notice.
+      # the answer, and the iteration-limit notice.
       # @param summary [Hash] Engine#turn_summary
       def render_turn_summary(summary)
         @view.finish_thinking_spinner
@@ -148,7 +165,6 @@ module Samagotchi
 
           @view.print_line(@view.format_tool_activity_line(activity))
         end
-        @view.emit_active_memories_line
         @view.print_line(summary[:output])
         @view.print_line("iteration limit reached") if summary[:resumable]
       end

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -135,6 +135,33 @@ module Samagotchi
         text.strip.empty? ? [] : lines
       end
 
+      # ── Turn ends: one set of words for the REPL, attached mode and the
+      # web (timing.js cancelLineText, format.js failedTurnText) ──────────
+
+      # A cancel's reason as the UIs name it (anything else as it is).
+      CANCEL_REASONS = { "ctrl_c" => "Ctrl-C", "user" => "stopped", "hook" => "by a hook" }.freeze
+      # Under a canceled prompt turn (a canceled continue is back where it
+      # started): its partial progress stays in the conversation.
+      ROLLBACK_HINT = "partial progress kept; !rollback restores the pre-turn state"
+
+      # "✕ turn canceled (Ctrl-C) · 3.1s"
+      def turn_canceled_line(reason, duration_ms)
+        label = reason.to_s.empty? ? nil : CANCEL_REASONS.fetch(reason.to_s, reason.to_s)
+        "#{paint("✕", 33)} turn canceled#{" (#{label})" if label}#{turn_duration_suffix(duration_ms)}"
+      end
+
+      # "✕ turn failed: <summary> · 2.0s"
+      def turn_failed_line(detail, duration_ms)
+        "#{paint("✕", 31)} turn failed: #{detail}#{turn_duration_suffix(duration_ms)}"
+      end
+
+      # A dim, indented line under a turn's end: what became of its prompt.
+      def turn_end_hint(text) = "  #{paint(text, 90)}"
+
+      def turn_duration_suffix(duration_ms)
+        duration_ms.nil? ? "" : " · #{format_elapsed_duration(duration_ms)}"
+      end
+
       private
 
       # The recap shown on return: dim, one "recap>" block, noting how many
@@ -174,9 +201,11 @@ module Samagotchi
 
       # ── The status line (the REPL's, and attached mode's idle one) ────────
 
-      # SAMAGOTCHI_STATUS_LINE=off hides it.
+      # status.line: off hides it.
+      STATUS_LINE_OFF = "off"
+
       def status_line_enabled?
-        value = ENV.fetch(STATUS_LINE_ENV, STATUS_LINE_ON).to_s.strip.downcase
+        value = Samagotchi::Config.get("status.line").to_s.strip.downcase
         !(value.empty? || value == STATUS_LINE_OFF || value == "0" || value == "false")
       end
 
@@ -204,10 +233,8 @@ module Samagotchi
         "model=#{model} (default: #{default_model})"
       end
 
-      # @param server [Hash, nil] the server's own numbers ({ctx_pct:, prompt_tokens:, ...})
       # @param estimate [Hash, nil] the kernel's estimate ({est_pct:, bucket:})
-      def status_context_text(server: nil, estimate: nil)
-        return format_server_context_segment(server) if server.is_a?(Hash)
+      def status_context_text(estimate: nil)
         return "" unless estimate.is_a?(Hash)
 
         pct = format("%.1f", estimate[:est_pct].to_f)
@@ -217,23 +244,6 @@ module Samagotchi
         "ctx=#{pct}% (#{bucket})"
       end
 
-      def format_server_context_segment(status)
-        pct = status[:ctx_pct]
-        base = pct ? "ctx=#{format('%.1f', pct)}%" : "ctx=srv"
-
-        tokens = []
-        prompt_tokens = status[:prompt_tokens]
-        completion_tokens = status[:completion_tokens]
-        total_tokens = status[:total_tokens]
-        tokens << "p=#{prompt_tokens}" if prompt_tokens
-        tokens << "c=#{completion_tokens}" if completion_tokens
-        tokens << "t=#{total_tokens}" if total_tokens
-
-        return base if tokens.empty?
-
-        "#{base} (#{tokens.join(' ')})"
-      end
-
       # @param label [String] "mem" for the used memories, "muted" for the
       #   session's --mute list
       def status_memory_text(names, limit, label: "mem")

data/lib/samagotchi/terminal_ui/input_support.rb

@@ -4,6 +4,7 @@ require "json"
 require "fileutils"
 require "reline"
 
+require_relative "../config"
 require_relative "../memory_paths"
 require_relative "../tools/memory"
 require_relative "../session_commands"
@@ -19,12 +20,10 @@ module Samagotchi
     # Included for private use; it keeps state in @next_input_prefill and
     # reads @no_default_input.
     module InputSupport
-      PROMPT_HISTORY_ENV = "SAMAGOTCHI_HISTORY_FILE"
       XDG_STATE_HOME_ENV = "XDG_STATE_HOME"
       PROMPT_HISTORY_FILE = "history.json"
       PROMPT_HISTORY_STATE_DIR = "samagotchi"
       PROMPT_HISTORY_LIMIT = 20
-      DEFAULT_INPUT_ENV = "SAMAGOTCHI_DEFAULT_INPUT"
       AT_PATH_COMPLETION_PREFIX = "@"
       MEMORY_COMPLETION_PREFIX = "#"
       AT_PATH_COMPLETION_MAX_CANDIDATES = 200
@@ -205,7 +204,7 @@ module Samagotchi
       end
 
       def history_file_path
-        explicit = ENV[PROMPT_HISTORY_ENV].to_s.strip
+        explicit = Samagotchi::Config.get("history.file").to_s.strip
         return explicit unless explicit.empty?
 
         File.join(xdg_state_home, PROMPT_HISTORY_STATE_DIR, PROMPT_HISTORY_FILE)
@@ -273,7 +272,7 @@ module Samagotchi
       def default_input_text
         return nil unless default_input_wanted?
 
-        default = ENV.fetch(DEFAULT_INPUT_ENV, nil)
+        default = Samagotchi::Config.get("default.input")
         return nil if default.nil? || default.strip.empty?
 
         default