samagotchi 0.15.0 → 0.17.0

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,
@@ -83,6 +92,23 @@ module Samagotchi
       nil
     end
 
+    # One turn's tool records from the session's saved analytics.json, in
+    # call order (iteration, then call_index), string-keyed as saved: what a
+    # join replays the turn's tool rows' durations from. Empty without a turn
+    # id (an older session's prompt), the file, or records.
+    # @param session_dir [String]
+    # @param turn_id [String, nil]
+    # @return [Array<Hash>]
+    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"]
+      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
+      []
+    end
+
     # "ctx 12%" for the session lists, "" when unknown.
     # @param pct [Float, nil]
     # @return [String]
@@ -101,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
@@ -196,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
@@ -248,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
@@ -256,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?
@@ -311,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
@@ -422,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,
@@ -430,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
 
@@ -531,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.
@@ -562,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/sessions_command.rb

@@ -148,15 +148,17 @@ module Samagotchi
         # ctx_pct: how full the context was after the last turn, or nil
         # waiting: the kind of question it waits on (question, approval,
         # hook: chi answer or the web answers it), or nil; waiting_id: its
-        # id, for chi answer --question
+        # id, for chi answer --question; relayed_to: the parent session (short
+        # id) whose card it also waits in (the approval relay), or nil
         keys = %i[id short_id desc cwd project updated_at live busy owner recap parent_id archived scratch ctx_pct waiting
-                  waiting_id]
+                  waiting_id relayed_to]
         @stdout.puts JSON.generate(summaries.map { |summary| summary.slice(*keys) })
       when "tsv"
         summaries.each { |summary| @stdout.puts "#{summary[:id]}\t#{summary[:desc]}" }
       else
         summaries.each do |summary|
-          state = if summary[:waiting] then "waiting"
+          state = if summary[:relayed_to] then "waiting (in parent #{summary[:relayed_to]})"
+                  elsif summary[:waiting] then "waiting"
                   elsif summary[:busy] then "running"
                   else summary[:live] ? "live" : summary[:status].to_s
                   end
@@ -206,7 +208,11 @@ module Samagotchi
         )
         # A question waits for an answer (chi answer, the web, chi --attach).
         live = s.pending_question && Samagotchi::SessionManager.worker_live?(s.id, state_dir: state_dir)
-        status = s.waiting_question(live: !!live) ? "waiting" : s.status
+        waiting = s.waiting_question(live: !!live)
+        status = if waiting&.dig(:relayed_to) then "waiting (in parent #{waiting[:relayed_to]})"
+                 elsif waiting then "waiting"
+                 else s.status
+                 end
         "#{s.id}  #{status.ljust(8)}  #{ctx.ljust(8)}  #{s.updated_at}  #{list_text.call(s)}#{flag}#{child}"
       end
       if project

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/attach_launcher.rb

@@ -38,7 +38,7 @@ module Samagotchi
       # @param muted_memories [Array<String>] --mute: hidden from a new session
       # @return [Symbol] :detached, :closed when the worker went away,
       #   :failed when the --model switch didn't go through, or (input from a
-      #   pipe) :turn_failed / :unanswered (AttachedLoop#run)
+      #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
               memories: [], muted_memories: [])
         client = connect(attach: attach, shared: shared, resume: resume, model: model,
@@ -56,6 +56,7 @@ module Samagotchi
           close_surface(surface)
         end
         report_unanswered(attached.unanswered, session_id: client.session_id) if ended == :unanswered && attached.unanswered
+        report_ended(ended)
         ended
       end
 
@@ -68,9 +69,17 @@ module Samagotchi
         err.flush
       end
 
+      # A turn of ours that ended with no answer (input from a pipe): one
+      # line on stderr, as the in-process `chi -p --non-interactive` says
+      # it, so a script doesn't take the silence for an answer (exit 1).
+      def report_ended(ended, err: $stderr)
+        err.puts(TerminalUI::EMPTY_ANSWER_ERROR) if ended == :empty_answer
+      end
+
       # chi's exit status after #run: 0 detached, 3 a question left waiting
       # for an answer (input from a pipe ran out; chi --attach or chi answer
-      # answers it), 1 anything else (a failed turn, the worker gone).
+      # answers it), 1 anything else (a failed turn, an empty answer, the
+      # worker gone).
       # @param ended [Symbol] what #run returned
       # @return [Integer]
       def exit_status(ended)

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -20,6 +20,7 @@ require_relative "../model_profile"
 require_relative "../output_formatter"
 require_relative "../session_commands"
 require_relative "../session_manager"
+require_relative "../session_metrics"
 require_relative "../guardrails/parent_approvals"
 require_relative "../tool_activity"
 require_relative "../web/message_parts"
@@ -143,8 +144,9 @@ module Samagotchi
       # asks it to exit too, and it does unless something still needs it.
       # @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
+      #   (wait_at_eof) :turn_failed when one of this run's prompts failed,
+      #   :empty_answer when one ended with no answer, 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)
@@ -259,7 +261,9 @@ module Samagotchi
           ask(event[:pending_question])
         when :question_answered then question_answered(event)
         when :question_cancelled
-          close_question("(question cancelled)") if @question
+          close_question(@question.closed_text(event[:reason])) if @question
+        # Relayed to the parent's card, or no longer: the widget says so.
+        when :question_relay then question_relayed(event)
         # Written while the session sat idle: shown at the open prompt. One
         # collected just as a turn started describes the chat before it.
         when :recap_ready then @screen.commit(recap_block(event[:recap])) unless @running || event[:recap].to_s.strip.empty?
@@ -306,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
@@ -445,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)
 
@@ -469,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?
@@ -569,6 +585,7 @@ module Samagotchi
         id = (event[:origin] || {})[:enqueued_id]
         ours = @open_ids.include?(id) || !@merged_ids.empty?
         @own_failed = true if ours && event[:type] == :turn_failed
+        @own_empty = true if ours && event[:type] == :turn_completed && event.dig(:turn_summary, :empty_answer)
         @open_ids.delete(id)
         @open_ids.subtract(@merged_ids)
         @merged_ids.clear
@@ -591,7 +608,9 @@ module Samagotchi
       # 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
+        return :turn_failed if @own_failed
+
+        @own_empty ? :empty_answer : :detached
       end
 
       def unanswered_question(pending)
@@ -757,6 +776,13 @@ module Samagotchi
         end
       end
 
+      def question_relayed(event)
+        return unless @question && @question.id == event[:id].to_s
+
+        @question.relayed_to = event[:relayed_to]
+        @screen.set_slot(:notes, @question.slot(paint: method(:paint)))
+      end
+
       def question_answered(event)
         return unless @question
         return close_question(nil) if @answered_ids.include?(event[:id])
@@ -925,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)
@@ -939,39 +966,76 @@ module Samagotchi
 
         @screen.commit(prompt_line(nil, exchange[last_user][:content]))
         Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
-        render_join_steps(messages, messages.index { |m| m.equal?(exchange[last_user]) })
-        # The saved answer is raw: the latest keeps its thinking, and one may
-        # be only a tool call.
-        answer = exchange[(last_user + 1)..].reverse_each
-                                           .map { |m| OutputFormatter.strip_markup(m[:content]) }
-                                           .find { |text| !text.empty? }
-        @screen.commit(last_lines(answer)) if answer
+        from = messages.index { |m| m.equal?(exchange[last_user]) }
+        render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
+        # A turn that ended with no answer: its notice, as live.
+        empty = messages.drop(from + 1).filter_map { |m| TurnNote.empty_answer(m) }.last
+        if empty
+          @screen.commit(format_empty_answer_line(empty[:retries] || empty["retries"]))
+        else
+          # The saved answer is raw: the latest keeps its thinking, and one may
+          # be only a tool call.
+          answer = exchange[(last_user + 1)..].reverse_each
+                                             .map { |m| OutputFormatter.strip_markup(m[:content]) }
+                                             .find { |text| !text.empty? }
+          @screen.commit(last_lines(answer)) if answer
+        end
         render_join_notes(messages, after_exchange: true)
       end
 
       # What the last exchange did, as the live turn drew it: each saved
-      # call's tool row (action, params, status from its result; no
-      # duration, which the session doesn't keep) and a plugin's steer
-      # where it came. The step texts stay out, as live (the ticker's).
-      def render_join_steps(messages, from)
+      # call's tool row (action, params, status from its result, and its
+      # duration from +durations+, the turn's saved tool records) and a
+      # plugin's steer where it came. The step texts stay out, as live (the
+      # ticker's).
+      def render_join_steps(messages, from, durations: [])
+        records = durations.dup
         messages.each_with_index.drop(from + 1).each do |m, i|
           if Steer.steer?(m)
             @screen.commit(format_steer_line(source: m[:source], text: m[:content]))
           elsif %w[model assistant].include?(m[:role].to_s)
             responses = messages.drop(i + 1).take_while { |r| r[:role].to_s == "tool_response" }
-            Array(Web::MessageParts.for_message(m, responses)&.dig(:tools)).each { |part| @screen.commit(join_tool_line(part)) }
+            Array(Web::MessageParts.for_message(m, responses)&.dig(:tools)).each do |part|
+              @screen.commit(join_tool_line(part, duration_ms: join_duration(records, part)))
+            end
           end
         end
       end
 
+      # The prompt's turn's saved tool records (SessionMetrics, in this
+      # machine's state dir, as #attach_images): none for a prompt with no
+      # turn id (an older session) or a session with no analytics.
+      def join_tool_records(prompt)
+        SessionMetrics.saved_tool_records(Session.session_dir(@client.session_id), prompt[:turn_id] || prompt["turn_id"])
+      rescue Session::InvalidId
+        []
+      end
+
+      # The duration of +part+'s call: the next record of its tool, in call
+      # order, consumed with the ones it skipped. By tool and order, not by
+      # iteration: an empty retry spends an iteration that left no message.
+      # nil (no duration shown) for a call that left none: it never
+      # finished, or a worker before turn ids saved it.
+      def join_duration(records, part)
+        return nil if part[:output].nil?
+
+        at = records.index { |r| r["tool"].to_s == part[:tool].to_s }
+        return nil unless at
+
+        duration = records[at]["duration_ms"]
+        records.shift(at + 1)
+        duration.is_a?(Numeric) ? duration : nil
+      end
+
       # A saved call's row; "no result" for a call the turn never answered
       # (it ended first).
-      def join_tool_line(part)
+      def join_tool_line(part, duration_ms: nil)
         output = part[:output]
         status = output.nil? ? "no result" : ToolActivity.tool_activity_status(output, part[:tool])
         activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
                      params: part[:params], status: status }
-        "#{format_tool_activity_line(activity)}#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
+        "#{format_tool_activity_line(activity, duration_ms: duration_ms)}" \
+          "#{format_tool_image_suffix(part[:images])}#{format_tool_diff_suffix(part[:diff])}"
       end
 
       # The context notes that came since the last prompt (all of them in a