samagotchi 0.16.0 → 0.17.0

data/lib/samagotchi/self_report.rb

@@ -7,6 +7,7 @@ require_relative "context_window"
 require_relative "session"
 require_relative "log_path"
 require_relative "model_profile"
+require_relative "model_overlay"
 require_relative "thinking"
 require_relative "served_model"
 require_relative "host_registry"
@@ -39,7 +40,8 @@ module Samagotchi
     end
 
     def fields(env: ENV)
-      model = model_name
+      default = model_name
+      model = session_model(env) || default
       [
         ["version", "#{VERSION} (ruby #{RUBY_VERSION})"],
         ["source", "#{SOURCE_DIR} (#{install_kind})"],
@@ -49,7 +51,8 @@ module Samagotchi
         ["project memories", Tools::MemoryRead.memories_dir("project", env: env)],
         ["sessions", Session.default_state_dir(env: env)],
         ["log", log_path(env)],
-        ["model", model || "(not configured)"],
+        ["model", model ? model_label(model, default, env) : "(not configured)"],
+        ["model key", model ? model_key_for(model, env) : "-"],
         ["host", model ? host_for(model, env) : "-"],
         ["api key", model ? api_key_for(model, env) : "-"],
         ["loop", model ? loop_for(model, env) : "-"],
@@ -125,6 +128,46 @@ module Samagotchi
       nil
     end
 
+    SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+    PARENT_SESSION_ENV = "SAMAGOTCHI_PARENT_SESSION"
+
+    # The model of the session this chi self runs in (its execute exports
+    # SAMAGOTCHI_SESSION_MODEL, the resolved ref, live after /model); nil
+    # outside a session's commands.
+    def session_model(env)
+      name = env[SESSION_MODEL_ENV].to_s.strip
+      name.empty? ? nil : name
+    end
+
+    # "splash:x (this session abcd1234; default main:y)", "main:y (this
+    # session abcd1234, the default)", or outside a session "main:y (default)".
+    def model_label(model, default, env)
+      return "#{model} (default)" unless session_model(env)
+
+      id = env[PARENT_SESSION_ENV].to_s
+      session = id.empty? || id == "chi" ? "this session" : "this session #{id[0, 8]}"
+      return "#{model} (#{session}, the default)" if default && same_model?(model, default, env)
+
+      "#{model} (#{session}; default #{default || "not configured"})"
+    end
+
+    def same_model?(one, other, env)
+      return true if one == other
+
+      ConfigFile.model_ref(one, env: env).ref == ConfigFile.model_ref(other, env: env).ref
+    rescue StandardError
+      false
+    end
+
+    # The memory overlay key (ModelOverlay.key_for the bare id, as the
+    # engine keys memory_write current_model_only): which `<name>.<key>.md`
+    # overlays are this model's.
+    def model_key_for(model, env)
+      ModelOverlay.key_for(HostRegistry.new(env: env).bare_name(model)) || "-"
+    rescue StandardError
+      ModelOverlay.key_for(model) || "-"
+    end
+
     def model_name
       ModelProfile.required_model_name
     rescue ArgumentError
@@ -147,6 +190,8 @@ module Samagotchi
       entry.chat? ? "chat (api: openai)" : "native (raw prompt)"
     end
 
+    NO_PROPS = "reported per turn (the server has no /props)"
+
     # chi self's one server call: a single-model llama.cpp answers any name
     # with the model it loaded, and its /props names it (model_alias). One
     # GET with the probe's short timeouts; a remote host isn't asked.
@@ -157,10 +202,11 @@ module Samagotchi
       bare = target.bare_model
       return "-" unless entry
       return "reported per turn (remote host)" if entry.remote?
+      return NO_PROPS if entry.chat?
 
       client = registry.client_for(entry)
       props = client.server_props(model: bare)
-      return "reported per turn (the server has no /props)" if props.nil?
+      return NO_PROPS if props.nil? || props.status == :http_error
       return "unknown (the server didn't answer; is it running?)" if props.status == :network_error
 
       served = ServedModel.from_props(props)

data/lib/samagotchi/send_command.rb

@@ -37,6 +37,8 @@ module Samagotchi
              chi send --wait [--timeout S] [--format json] ID
         Sends a message to each session, as if typed in it: a turn starts,
         or a running one picks it up. A stopped session's worker starts.
+        A session command (/model x, !cmd) runs as the command; --wait
+        then has no reply to wait for (exit 0, status command).
         -m TEXT     the message; stdin, when piped too, goes above it as a
                     quote (context); without -m, stdin is the message
         --image PATH
@@ -64,7 +66,7 @@ module Samagotchi
                     (--wait) one JSON object on stdout, whatever the end:
                     status answered (text), question (question,
                     answer_with), running, or failed, canceled,
-                    no_answer, error, worker_gone, stopped (detail)
+                    no_answer, error, worker_gone, stopped, command (detail)
         Exit with --wait: 0 answered, 1 failed or gone, 2 usage, 3 a
         question waits, 4 still running (--timeout), 130 Ctrl-C.
         Only sessions on this machine. Answers show in the attached TUI
@@ -246,23 +248,27 @@ module Samagotchi
         error_line("chi send: refused: #{refusal}")
         return 1
       end
+      # With images the web's way: idle (the message names it in the
+      # lists), the images copied in, then the message as a turn. So too a
+      # line that may be a session command (/model x): its worker's answer
+      # says whether it ran as one.
+      through_worker = images || command_like?(prompt)
       begin
-        # With images the web's way: idle (the message names it in the
-        # lists), the images copied in, then the message as a turn.
-        start = images ? { prompt: nil, title: prompt } : { prompt: prompt }
+        start = through_worker ? { prompt: nil, title: prompt } : { prompt: prompt }
         session = SessionManager.spawn_session(**start, working_directory: options[:dir],
                                                         model_name: options[:model], state_dir: @state_dir)
       rescue StandardError => e
         error_line("chi send: could not start a session: #{e.message}")
         return 1
       end
-      if images
+      if through_worker
         return 1 unless deliver_new(session, prompt)
       else
         @info.puts("#{session.id}  started")
       end
       @session_id = session.id
       return 0 unless options[:wait]
+      return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
                                  timeout: options[:timeout])
@@ -297,6 +303,7 @@ module Samagotchi
       cursor = ReplyWait.newest_reply(id, state_dir: @state_dir)
       baseline = baseline_of(session)
       return 1 unless deliver(id, prompt)
+      return report_command(id) if @sent_command
 
       wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout])
     end
@@ -352,10 +359,36 @@ module Samagotchi
         return false
       end
 
-      @info.puts("#{session.id}  started#{with_images}")
+      @sent_command = command_ack?(result[:ack])
+      @info.puts("#{session.id}  started#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true
     end
 
+    SENT_COMMAND = "sent as a session command"
+
+    # Whether the worker took the message as a session command (a POST
+    # /turn whose line is one answers with its command_id).
+    def command_ack?(ack) = ack.is_a?(Hash) && !ack["command_id"].to_s.empty?
+
+    # Whether +text+ may be a session command, which only its worker knows
+    # (a bundle's too).
+    def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
+
+    # --wait after a message that ran as a session command: no reply comes
+    # for it. Its output shows where the session is open.
+    # @return [Integer] 0
+    def report_command(id)
+      detail = "#{SENT_COMMAND}: no reply to wait for (its output shows in chi --attach #{id} or the web)"
+      if @json
+        @stdout.puts(JSON.generate({ status: "command", session_id: id, detail: detail }))
+        @stdout.flush
+        @reported = true
+      else
+        @stderr.puts("#{id[0, 8]}  #{detail}")
+      end
+      CLI::Exit::OK
+    end
+
     # @return [Boolean] whether the message was queued
     def deliver(id, prompt)
       short = id[0, 8]
@@ -373,6 +406,12 @@ module Samagotchi
         return false
       end
 
+      @sent_command = command_ack?(result[:ack])
+      if @sent_command
+        @info.puts("#{short}  #{SENT_COMMAND}")
+        return true
+      end
+
       # A busy worker runs a message with images as its own next turn
       # rather than merging it into the running one.
       note = if owner.nil? then " (started its worker)"

data/lib/samagotchi/session_metrics.rb

@@ -17,15 +17,24 @@ module Samagotchi
   #
   # Each finished turn leaves a record (status, timings, model, prompt and
   # completion tokens, tool calls, iterations, retries); session totals are
-  # sums over the records, so a worker that stops and wakes again (a new
-  # collector) keeps counting: #session_id= loads the records already saved.
+  # sums over the records, kept as running counters as records are added, so
+  # a worker that stops and wakes again (a new collector) keeps counting:
+  # #session_id= loads the records already saved.
   # Only prompt and completion counts, which every backend reports the same
   # way, are kept.
   #
-  # A snapshot is surfaced via Engine#session_state_snapshot and (optionally)
-  # persisted to a sibling analytics.json next to the session file. The event
-  # trail itself goes to the debug log (LogSubscriber).
+  # A snapshot is surfaced via Engine#session_state_snapshot (the Bridge's
+  # /state, /snapshot, /stats and SSE frames) and persisted to a sibling
+  # analytics.json next to the session file. The live snapshot carries the
+  # totals and only the recent records (the newest finished turn's, plus any
+  # not yet saved, at most LIVE_RECORDS_CAP turns), so it stays the same size
+  # however long the session runs; analytics.json holds every record. The
+  # event trail itself goes to the debug log (LogSubscriber).
   class SessionMetrics
+    # The most turns (with their tool calls) a live snapshot carries: the
+    # unsaved ones of a collector whose saves keep failing stay bounded.
+    LIVE_RECORDS_CAP = 20
+
     # Per-turn transient state, reset on each turn_started.
     TurnState = Struct.new(
       :session_id,
@@ -118,6 +127,11 @@ module Samagotchi
       @turn = nil
       @turn_records = []
       @tool_records = []
+      # How many turn records the last successful save (or the load) holds,
+      # and how many were loaded (a woken collector's live records start empty).
+      @persisted_turns = 0
+      @loaded_turns = 0
+      reset_totals
     end
 
     # /model: the window and prompt profile a turn reported were the old
@@ -213,51 +227,31 @@ module Samagotchi
     # The session totals are sums over the turn records (the ones loaded from
     # disk and this process's), with the running turn's calls, iterations and
     # finished generations counted at once, so /stats agrees mid-turn.
+    # :turn_records / :tool_records are the recent ones only: the newest
+    # finished turn's and any not yet saved (at most LIVE_RECORDS_CAP turns),
+    # with the running turn's finished calls; the full history is the
+    # session's analytics.json.
     # @return [Hash] the current summary snapshot
     def snapshot
-      @mutex.synchronize do
-        records = @turn_records
-        turn = @turn
-        in_flight = turn ? turn.tool_calls_by_id.values : []
-        tools = @tool_records + in_flight
-        {
-          session_id: @session_id,
-          turns: records.size + (turn ? 1 : 0),
-          cancellations: records.count { |record| record[:status] == "canceled" },
-          tokens: {
-            prompt_sum: sum(records, :prompt_tokens_sum) + (turn&.prompt_sum || 0),
-            completion_sum: sum(records, :completion_tokens) + (turn&.completion_sum || 0),
-            source: combined_source(records.map { |record| record[:token_source] } + (turn&.token_sources || []))
-          },
-          context: context_block(records),
-          profile: @profile,
-          profile_source: @profile_source,
-          served_model: @served_model,
-          served_model_for: @served_model_for,
-          tool_calls_total: tools.size,
-          tool_calls_by_tool: tools.map { |tool| tool[:tool].to_s }.reject(&:empty?).tally,
-          tool_errors: @tool_records.count { |tool| tool[:status] == "error" },
-          iterations_total: sum(records, :iterations) + (turn&.iteration_count || 0),
-          gen_latency_ms: (sum(records, :gen_ms) + (turn&.gen_latency_accum || 0)).round,
-          retries: sum(records, :retries) + (turn&.retries || 0),
-          started_at: @started_at,
-          last_activity_at: @last_activity_at,
-          session_duration_ms: elapsed_ms(@session_started_monotonic),
-          turn_records: @turn_records.map(&:dup),
-          tool_records: @tool_records.map(&:dup),
-          active_turn: active_turn_snapshot,
-          active_tools: active_tool_snapshots
-        }
-      end
+      @mutex.synchronize { build_snapshot(:recent) }
+    end
+
+    # The served model a generation last reported and the name asked for
+    # then, without building a snapshot (Engine#served_model).
+    # @return [Hash] :served_model, :served_model_for
+    def served_report
+      @mutex.synchronize { { served_model: @served_model, served_model_for: @served_model_for } }
     end
 
-    # Persist the summary snapshot to a sibling analytics.json in the session
-    # directory. Atomic write; failures are swallowed (analytics must never
-    # break the running session).
+    # Persist the summary snapshot, with every record, to a sibling
+    # analytics.json in the session directory. Atomic write; failures are
+    # swallowed (analytics must never break the running session).
     # @param state_dir [String, nil]
     # @return [Boolean] true on success
     def persist(state_dir: nil)
-      sid = @mutex.synchronize { @session_id }
+      sid, data, turn_count = @mutex.synchronize do
+        [@session_id, build_snapshot(:all).merge(active_turn: nil, active_tools: []), @turn_records.size]
+      end
       return false if sid.nil? || sid.to_s.empty?
 
       # Omitting state_dir lets Session.session_dir fall back to the default
@@ -265,7 +259,8 @@ module Samagotchi
       # 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(snapshot.merge(active_turn: nil, active_tools: [])) + "\n")
+      AtomicFile.write(path, JSON.pretty_generate(data) + "\n")
+      @mutex.synchronize { @persisted_turns = [@persisted_turns, turn_count].max }
       true
     rescue StandardError
       false
@@ -273,6 +268,58 @@ module Samagotchi
 
     private
 
+    # Caller holds the mutex. +records+: :recent (the live snapshot) or :all
+    # (analytics.json).
+    def build_snapshot(records_mode)
+      totals = @totals
+      turn = @turn
+      in_flight = turn ? turn.tool_calls_by_id.values : []
+      {
+        session_id: @session_id,
+        turns: @turn_records.size + (turn ? 1 : 0),
+        cancellations: totals[:cancellations],
+        tokens: {
+          prompt_sum: totals[:prompt_sum] + (turn&.prompt_sum || 0),
+          completion_sum: totals[:completion_sum] + (turn&.completion_sum || 0),
+          source: combined_source(totals[:token_sources] + (turn&.token_sources || []))
+        },
+        context: context_block(@turn_records),
+        profile: @profile,
+        profile_source: @profile_source,
+        served_model: @served_model,
+        served_model_for: @served_model_for,
+        tool_calls_total: @tool_records.size + in_flight.size,
+        tool_calls_by_tool: tally_into(totals[:by_tool].dup, in_flight),
+        tool_errors: totals[:tool_errors],
+        iterations_total: totals[:iterations] + (turn&.iteration_count || 0),
+        gen_latency_ms: (totals[:gen_ms] + (turn&.gen_latency_accum || 0)).round,
+        retries: totals[:retries] + (turn&.retries || 0),
+        started_at: @started_at,
+        last_activity_at: @last_activity_at,
+        session_duration_ms: elapsed_ms(@session_started_monotonic),
+        **records_view(records_mode),
+        active_turn: active_turn_snapshot,
+        active_tools: active_tool_snapshots
+      }
+    end
+
+    # The records a snapshot carries, copied. :all is every record; :recent
+    # the newest turn this collector finished (live before its save lands)
+    # and the unsaved ones (capped), and the tool records of those turns and
+    # of the running one. Records are appended in turn order, so both come
+    # from the tails. Caller holds the mutex.
+    def records_view(mode)
+      return { turn_records: @turn_records.map(&:dup), tool_records: @tool_records.map(&:dup) } if mode == :all
+
+      unsaved = @turn_records.size - @persisted_turns
+      count = unsaved.clamp(@turn_records.size > @loaded_turns ? 1 : 0, LIVE_RECORDS_CAP)
+      turns = @turn_records.last(count)
+      ids = turns.to_set { |record| record[:id] }
+      ids << @turn.id if @turn
+      tools = @tool_records.reverse_each.take_while { |tool| ids.include?(tool[:turn_id]) }.reverse
+      { turn_records: turns.map(&:dup), tool_records: tools.map(&:dup) }
+    end
+
     def begin_turn(event)
       @mutex.synchronize do
         unless @session_id || event[:session_id].to_s.empty?
@@ -328,6 +375,7 @@ module Samagotchi
           record[:cancellation_reason] = reason.to_s unless reason.nil? || reason.to_s.empty?
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
+          count_turn(record)
         end
         @turn = nil
       end
@@ -439,7 +487,7 @@ module Samagotchi
         return unless active
 
         finished_at = now
-        @tool_records << active.slice(
+        record = active.slice(
           :id, :turn_id, :iteration, :call_index, :tool, :started_at
         ).merge(
           status: status.empty? ? "ok" : status,
@@ -447,6 +495,8 @@ module Samagotchi
           # Less a guardrail approval wait (ToolRunner's waited_ms).
           duration_ms: [elapsed_ms(active[:started_monotonic]) - event[:waited_ms].to_i, 0].max
         )
+        @tool_records << record
+        count_tool(record)
       end
     end
 
@@ -548,8 +598,15 @@ module Samagotchi
       prior = JSON.parse(File.read(path))
       return unless prior.is_a?(Hash)
 
-      @turn_records = loaded_records(prior["turn_records"]) + @turn_records
+      loaded_turns = loaded_records(prior["turn_records"])
+      @turn_records = loaded_turns + @turn_records
       @tool_records = loaded_records(prior["tool_records"]) + @tool_records
+      @persisted_turns = @loaded_turns = loaded_turns.size
+      # Once per collector: recount in record order (the tally's key order
+      # stays first-seen).
+      reset_totals
+      @turn_records.each { |record| count_turn(record) }
+      @tool_records.each { |record| count_tool(record) }
       @started_at = earliest_timestamp(prior["started_at"], @started_at)
       @last_activity_at ||= prior["last_activity_at"]
       # The window last seen, until this process's first generation reports.
@@ -579,8 +636,40 @@ module Samagotchi
       }
     end
 
-    def sum(records, key)
-      records.sum { |record| record[key].is_a?(Numeric) ? record[key] : 0 }
+    # The session totals over the finished records, as running counters
+    # (#snapshot adds the running turn). Caller holds the mutex.
+    def reset_totals
+      @totals = { cancellations: 0, prompt_sum: 0, completion_sum: 0, token_sources: [], iterations: 0,
+                  gen_ms: 0, retries: 0, by_tool: {}, tool_errors: 0 }
+    end
+
+    def count_turn(record)
+      totals = @totals
+      totals[:cancellations] += 1 if record[:status] == "canceled"
+      totals[:prompt_sum] += number(record[:prompt_tokens_sum])
+      totals[:completion_sum] += number(record[:completion_tokens])
+      totals[:iterations] += number(record[:iterations])
+      totals[:gen_ms] += number(record[:gen_ms])
+      totals[:retries] += number(record[:retries])
+      source = record[:token_source]
+      totals[:token_sources] |= [source.to_s] unless source.nil?
+    end
+
+    def count_tool(record)
+      @totals[:tool_errors] += 1 if record[:status] == "error"
+      tally_into(@totals[:by_tool], [record])
+    end
+
+    def tally_into(counts, tools)
+      tools.each do |tool|
+        name = tool[:tool].to_s
+        counts[name] = counts.fetch(name, 0) + 1 unless name.empty?
+      end
+      counts
+    end
+
+    def number(value)
+      value.is_a?(Numeric) ? value : 0
     end
 
     # server, estimate, or mixed when both kinds of counts (or a turn that

data/lib/samagotchi/system_prompt.rb

@@ -23,6 +23,15 @@ module Samagotchi
   class SystemPrompt
     AGENT_DESCRIPTION_FILE = "AGENT.md"
 
+    # The model a session runs on, as the prompt names it: the resolved
+    # ref, its host ("name, host:port" or url), the memory overlay key, and
+    # what a llama.cpp server says it serves when that differs (else nil).
+    # fallback_key: the key an alias typed for the model used to key overlays
+    # by (read when +key+ has none, as memory_read does); not shown.
+    ModelIdentity = Data.define(:ref, :host, :key, :served, :fallback_key) do
+      def initialize(ref:, host:, key:, served: nil, fallback_key: nil) = super
+    end
+
     # Always auto-loaded from the system scope unless muted (B-light).
     DEFAULT_SYSTEM_MEMORIES = %w[identity].freeze
 
@@ -34,10 +43,12 @@ module Samagotchi
     # @param tools    [#call] → Tools::Registry
     # @param session  [#call] → Session, nil
     # @param thinking [#call] → Symbol, the effective model's level (Thinking)
+    # @param model    [#call] → ModelIdentity, nil (the section is left out)
     # @param memories [Array<String>] the --memory list
     # @param muted_memory_names [Array<String>] normalized (MutedMemories)
-    def initialize(profile:, tools:, session:, thinking:, memories: [], muted_memory_names: [])
+    def initialize(profile:, tools:, session:, thinking:, model: -> {}, memories: [], muted_memory_names: [])
       @profile_lookup = profile
+      @model_lookup = model
       @tools_lookup = tools
       @session_lookup = session
       @thinking_lookup = thinking
@@ -223,7 +234,7 @@ module Samagotchi
         "Project memories:\n#{project_index}",
         "System memories:\n#{system_index}"
       ].join("\n\n")
-      [thinking_token + base, rg_guidance, project_description, project_location, current_session, memory_sections, system_identity_section, explicit_memory_section].compact.join("\n")
+      [thinking_token + base, rg_guidance, project_description, project_location, current_model, current_session, memory_sections, system_identity_section, explicit_memory_section].compact.join("\n")
     end
 
     # B-light: auto-preload the built-in identity memory.
@@ -235,7 +246,7 @@ module Samagotchi
       DEFAULT_SYSTEM_MEMORIES.each do |name|
         next if memory_muted?(name)
 
-        body = Tools::MemoryRead.call(name, scope: "system")
+        body = Tools::MemoryRead.call(name, scope: "system", **overlay_keys)
         next if body.start_with?("Error:")
         next if body.strip.empty?
 
@@ -248,6 +259,17 @@ module Samagotchi
 
     # ── Memory helpers ─────────────────────────────────────────────────────────
 
+    # The session model's overlay keys, so the prompt's own memory bodies
+    # (identity, preloads) get `<name>.<key>.md` as memory_read gives it.
+    def overlay_keys
+      model = @model_lookup.call
+      return {} unless model&.key
+
+      { model_key: model.key, fallback_model_key: model.fallback_key }
+    rescue StandardError
+      {}
+    end
+
     # The scope's index text without the muted memories' lines.
     def read_memory_index(scope)
       BundleNeeds.annotate_index(MutedMemories.filter_index(Tools::MemoryRead.call("", scope: scope), @muted_memory_names), scope)
@@ -297,7 +319,7 @@ module Samagotchi
         names = raw.split(",").map(&:strip).reject(&:empty?)
         names.each do |name|
           scope, actual_name = split_memory_scope(name)
-          body = Tools::MemoryRead.call(actual_name, scope: scope)
+          body = Tools::MemoryRead.call(actual_name, scope: scope, **overlay_keys)
           if body.start_with?("Error:")
             source = Array(@config_memories).include?(raw) ? "memory '#{name}' (from config memories:)" : "--memory '#{name}'"
             Log.warn(:memory, "preload_failed", echo: "Warning: #{source} could not be loaded (#{body})", memory: name)
@@ -378,6 +400,25 @@ module Samagotchi
       path
     end
 
+    # The model this session runs on. A model guesses its name from
+    # training (a fine-tune often knows only its base model's), so the line
+    # says to answer from here. It depends only on the effective model, and
+    # the prompt is rebuilt only on a switch (#reset!): no per-turn churn.
+    def current_model
+      model = @model_lookup.call
+      return nil unless model && !model.ref.to_s.empty?
+
+      details = [model.host, model.key && "model key #{model.key}", model.served && "the server says it serves #{model.served}"]
+      details = details.compact.reject(&:empty?)
+      where = details.empty? ? "" : " (#{details.join("; ")})"
+      "Model: this session runs on #{model.ref}#{where}.\n" \
+        "Asked which model you are, answer with this line, not from training: a fine-tuned model often knows only " \
+        "its base model's name, but this session runs what is named here; it changes only with /model. " \
+        "Guidance for this model only goes in memory overlays: memory_write current_model_only: true."
+    rescue StandardError
+      nil
+    end
+
     # Fixed for the session's lifetime, so it doesn't churn the prompt cache.
     # Omitted until a session is attached (run_turn / TerminalUI set it). A
     # delegated session (parent_id set) is told who reads its reply.

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -310,7 +310,13 @@ module Samagotchi
         return detach("Detached; the session keeps running. Re-attach with: chi --attach #{@client.session_id}") if line.nil?
 
         text = line.strip
-        return answer_question(text) if @question
+        if @question
+          # /detach leaves the question open, as Ctrl-D does; any other
+          # line (/exit too) is read as the answer.
+          return submit(nil) if command_registry.lookup_local(text)&.id == :detach
+
+          return answer_question(text)
+        end
 
         # The terminal's own commands (SessionCommands registers them, the
         # REPL reads the same words). Before the continue offer: the
@@ -449,7 +455,12 @@ module Samagotchi
       # too, so nothing waits here.
       def send_command(line)
         reply = @client.post_command(line: line, client_id: @client_id)
-        return if reply.status == 202
+        if reply.status == 202
+          # Input from a pipe ends once its output is in (#command_ran).
+          command_id = reply.json&.fetch("command_id", nil)
+          @open_ids << command_id if command_id && @wait_at_eof
+          return
+        end
         return @screen.commit(stale_worker("run commands")) if reply.status == 404
         return @screen.commit("could not run the command (#{LATE})") if too_late?(reply)
 
@@ -473,6 +484,7 @@ module Samagotchi
       end
 
       def command_ran(event)
+        @open_ids.delete(event[:command_id])
         @screen.commit(prompt_line(event[:client_id], event[:line])) unless own?(event[:client_id]) || event[:anytime] || event[:card]
         output = event[:output].to_s
         if output.empty?
@@ -939,7 +951,8 @@ module Samagotchi
         return if text.empty?
 
         @screen.commit("#{paint(PROMPT, 92)}#{text}")
-        send_prompt(text)
+        # As if typed: a session command runs as the command.
+        command_registry.command?(text) ? send_command(text) : send_prompt(text)
       end
 
       def render_join_header(messages)

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -63,7 +63,8 @@ module Samagotchi
         when :generation_chunk
           @view.generation_feedback_chunk(event)
         when :tool_call_started
-          @tool_started_at[tool_call_key(event)] = @clock.call
+          # A joined running call (a snapshot's replay) started elapsed_ms ago.
+          @tool_started_at[tool_call_key(event)] = @clock.call - (event[:elapsed_ms].to_f / 1000)
           @view.tool_call_feedback_started(event)
         when :tool_call_completed
           @view.clear_generation_retry

data/lib/samagotchi/terminal_ui.rb

@@ -232,6 +232,10 @@ module Samagotchi
       @engine.session = session
       messages = messages_for(session)
 
+      # As typed at the prompt: a session command (/models, !ls) runs as
+      # the command, not as a turn.
+      return run_one_shot_command(session) if @prompt && @non_interactive && command_registry.command?(@prompt)
+
       if @prompt && @non_interactive
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
@@ -281,6 +285,22 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
+    # `chi -p "/models" --non-interactive`: the command's output; a refused
+    # one fails the run (bin/chi exits 1). The session is saved only when
+    # the command changed it.
+    # @return [Symbol, nil] :turn_failed when the command was refused
+    def run_one_shot_command(session)
+      line = @prompt.strip
+      result = begin
+        @commands.run(line)
+      rescue StandardError => e
+        SessionCommands::Result.new(status: :error, output: "#{line.split.first}: #{e.message}", changed: [])
+      end
+      @surface.commit(result.output) unless result.output.to_s.empty?
+      session.save unless Array(result.changed).empty?
+      :turn_failed if result.status == :error
+    end
+
     # Delete the scratch session, the last thing the REPL does. Quiet after
     # a one-shot or on the way out of an error or a signal.
     def delete_scratch(session, quiet:)
@@ -1184,6 +1204,10 @@ module Samagotchi
 
     # A ? read of its own, off a terminal (specs, pipes): $stdin.gets.
     def read_choice_line(question_prompt)
+      # Off a terminal the ? prompt can't be taken back: at the input's end
+      # it would stay bare above the summary. eof? waits as gets would.
+      return nil if !$stdin.tty? && $stdin.eof?
+
       @surface.set_slot(:editor, [question_prompt])
       line = $stdin.gets
       # A pipe doesn't echo: the line completes the ? prompt here, once,