samagotchi 0.43.0 → 0.45.0

data/lib/samagotchi/model_profile.rb

@@ -187,7 +187,6 @@ module Samagotchi
     # named before the worker's first turn fails on it. Only a warning: some
     # hosts serve ids they don't list (a one-model llama.cpp server takes any
     # name, OpenRouter's :nitro variants), so the session starts anyway.
-    # Never asks a host.
     #
     # Only a ref that names a host is checked (its alias resolved first, as
     # ModelRef.parse does), and only against that host's own list: a bare id
@@ -195,11 +194,24 @@ module Samagotchi
     # single list can judge it. Nothing is checked either without a saved
     # list for the host or with one older than ModelListStore::TTL_SECONDS
     # (a week: the host may serve different models by now).
+    #
+    # A saved list that lacks the id may itself be stale by content: a
+    # one-model server was reloaded with another model while the list still
+    # names the old one. So a miss in a saved list older than
+    # RELIST_AFTER_SECONDS re-lists that one host once, judges again against
+    # what it lists now, and lets the saved list take the re-list's ids (the
+    # default re-list saves them too). A younger saved list, a hit, no list,
+    # a stale list (TTL_SECONDS) or a ref that names no host never asks a
+    # host; a re-list that fails, times out (RE_LIST_TIMEOUT_SECONDS) or
+    # lists nothing warns from the saved list (a host that is down is no
+    # evidence either way).
     # @param hosts [Hash, nil] the hosts a prefix may name (a HostRegistry's
     #   entries); config.yml's by default
     # @param lists [#read] ModelListStore by default
+    # @param relist [#call, nil] how a miss re-lists the host:
+    #   (host_name, env) -> ids or nil. HostRegistry#list_models by default.
     # @return [String, nil]
-    def self.model_warning(model_name, env: ENV, hosts: nil, lists: nil)
+    def self.model_warning(model_name, env: ENV, hosts: nil, lists: nil, relist: nil)
       require_relative "config"
       require_relative "model_list_store"
       hosts ||= Samagotchi::ConfigFile.hosts_config(env: env)
@@ -210,10 +222,67 @@ module Samagotchi
 
       list = lists.read(env: env)[host.to_s.strip.downcase]
       return nil if list.nil? || list.stale? || list.known?(parsed.id)
+      # A saved list this recent is taken at its word. Re-listing every miss
+      # would make each launch of an id a host serves but never lists (a
+      # gateway's round-robin aliases) pay the re-list's cap and warn
+      # anyway; a list that old is the case worth catching (a one-model
+      # server reloaded with another model).
+      return unknown_model_message(parsed.id, host, list.ids) if list.age < RELIST_AFTER_SECONDS
+
+      fresh_ids = relist_or_nil(relist || default_relist(hosts), host, env)
+      # A re-list that answered: the saved list catches up (the default
+      # re-list, HostRegistry#list_models, saved it already).
+      if fresh_ids
+        Samagotchi::ModelListStore.save(host, fresh_ids, env: env)
+        return nil if fresh_ids.any? { |id| id.to_s.casecmp?(parsed.id.to_s.strip) }
+
+        return unknown_model_message(parsed.id, host, fresh_ids)
+      end
 
+      # No answer (failed, timed out, listed nothing): the saved list stands.
       unknown_model_message(parsed.id, host, list.ids)
     end
 
+    # How long a miss's re-list may take before it is treated as failed: a
+    # spawn (`chi send --new --model`, delegate) warns from the saved list
+    # then, rather than wait on a slow host.
+    RE_LIST_TIMEOUT_SECONDS = 5
+
+    # A saved list younger than this is not re-listed on a miss (the other
+    # way it can be wrong: stale by CONTENT within its TTL, a one-model
+    # server reloaded with another model). A host that serves ids it never
+    # lists (a gateway's round-robin aliases) would otherwise pay the
+    # re-list's cap on every launch.
+    RELIST_AFTER_SECONDS = 10 * 60
+
+    # The default re-list: one HostRegistry, one host listed (and saved).
+    # Bounded like `chi models`' `wait:`: a thread still listing at the cap
+    # is left running and its answer ignored (only a short-lived spawn is
+    # ever here).
+    # @return [#call] (host_name, env) -> ids or nil
+    def self.default_relist(hosts)
+      lambda do |host_name, relist_env|
+        require_relative "host_registry"
+        registry = Samagotchi::HostRegistry.new(hosts_config: hosts, env: relist_env)
+        answer = nil
+        thread = Thread.new { answer = registry.list_models(host_name) }
+        thread.join(RE_LIST_TIMEOUT_SECONDS)
+        answer
+      end
+    end
+    private_class_method :default_relist
+
+    # The re-list's ids, or nil when it fails, times out or lists nothing.
+    # A failing re-list is no evidence either way: the caller warns from the
+    # saved list.
+    def self.relist_or_nil(relist, host, env)
+      ids = relist.call(host, env)
+      ids.respond_to?(:any?) && ids.any? ? ids : nil
+    rescue StandardError
+      nil
+    end
+    private_class_method :relist_or_nil
+
     # The warning for an id the host doesn't list, with up to three close
     # ids (Config.near_names) when there are any.
     def self.unknown_model_message(id, host, ids)

data/lib/samagotchi/plugin/context.rb

@@ -105,13 +105,15 @@ module Samagotchi
 
       # Whether the session is a delegate child (Session#delegate?): a task
       # another session handed over, not the user's own.
-      def delegate?
-        id = session_id
-        return false unless id
-
-        Session.load(id, state_dir: @host.state_dir&.call || Session.default_state_dir).delegate?
-      rescue ArgumentError
-        false
+      def delegate? = !!saved_session&.delegate?
+
+      # Whether the session is a fork (ctx.sessions.fork: /btw keep, a
+      # plugin's): it has a parent and isn't a delegate child, and it
+      # started from a conversation, so its first prompt isn't its first
+      # user message.
+      def fork?
+        session = saved_session
+        !session.nil? && !session.parent_id.nil? && !session.delegate?
       end
 
       # @return [String] the session's working directory
@@ -297,6 +299,16 @@ module Samagotchi
         helper.respond_to?(:call) ? helper : nil
       end
 
+      # The session's file as saved, nil without an id or a file.
+      def saved_session
+        id = session_id
+        return nil unless id
+
+        Session.load(id, state_dir: @host.state_dir&.call || Session.default_state_dir)
+      rescue ArgumentError
+        nil
+      end
+
       def deep_freeze(value)
         case value
         when Hash then value.to_h { |k, v| [deep_freeze(k), deep_freeze(v)] }.freeze

data/lib/samagotchi/self_report.rb

@@ -197,14 +197,43 @@ module Samagotchi
     # takes them at its next build (/stats names the ones it carries).
     def model_notes_for(model, env)
       bare = HostRegistry.new(env: env).bare_name(model)
-      notes = ModelNotes.for(name: bare, key: ModelOverlay.key_for(bare), muted: session_muted(env), env: env,
-                             warn: false)
+      key = ModelOverlay.key_for(bare)
+      notes = ModelNotes.for(name: bare, key: key, fallback_key: fallback_model_key(model, key, env),
+                             muted: session_muted(env), env: env, warn: false)
       text = PromptNote.text(notes.map { |note| PromptNote.from_note(note) })
       text.empty? ? "none" : text
     rescue StandardError => e
       "(unreadable: #{e.message})"
     end
 
+    # The overlay key read when the key has none (SystemPrompt::ModelIdentity
+    # #fallback_key): the key of the name the model was typed as, when the
+    # session chi self runs in has one (an alias), else of the name chi self
+    # reports. nil when that is the key itself. Read-only, never raising.
+    def fallback_model_key(model, key, env)
+      typed = session_typed_model(env) || model
+      typed_key = ModelOverlay.key_for(HostRegistry.new(env: env).parse_qualified_model(typed).last)
+      typed_key == key ? nil : typed_key
+    rescue StandardError
+      nil
+    end
+
+    # The model name the session chi self runs in was typed as (an alias),
+    # its model_typed, else nil.
+    def session_typed_model(env)
+      id = env[PARENT_SESSION_ENV].to_s
+      return nil if id.empty? || !Session.valid_id?(id)
+
+      state_dir = Session.default_state_dir(env: env)
+      return nil unless Session.exist?(id, state_dir: state_dir)
+
+      session = Session.load(id, state_dir: state_dir)
+      typed = session.model_typed.to_s.strip
+      typed.empty? ? nil : typed
+    rescue StandardError
+      nil
+    end
+
     # The --mute list of the session chi self runs in (its execute exports
     # SAMAGOTCHI_PARENT_SESSION); [] outside one.
     def session_muted(env)

data/lib/samagotchi/session_commands.rb

@@ -39,6 +39,9 @@ module Samagotchi
     # /exit --delete: delete the session on the way out.
     EXIT_DELETE_FLAG = "--delete"
 
+    # /help's note per listed mid_turn (the web's command list says the same).
+    MID_TURN_NOTES = { "anytime" => "mid-turn too", "depends" => "show: mid-turn too" }.freeze
+
     # @!attribute status [Symbol] :ok, or :error when the line was refused
     # @!attribute output [String, nil] what to tell the user
     # @!attribute changed [Array<Symbol>] :messages and/or :model
@@ -52,21 +55,28 @@ module Samagotchi
     # Puts the built-in commands into +registry+, in lookup order (!rollback
     # before !cmd): the ones #run runs, then the UIs' own (local: Tab and
     # help only).
+    #
+    # While a turn runs, a show form (the name alone) runs at once beside
+    # it (it only reads); setting forms and !cmd run after the turn; !rollback
+    # and /continue are refused (Commands::Registry::MID_TURN).
     def self.register_builtins(registry)
       registry.register(ROLLBACK_COMMAND, "discard the interrupted turn and restore the pre-turn state",
                         id: :rollback) { |_text| rollback }
       registry.register("!", "run a shell command; its output goes into the conversation",
-                        id: :shell, match: ->(text) { text.match?(/\A!\s*\S/) }) { |text| shell(text) }
+                        id: :shell, mid_turn: :queue, match: ->(text) { text.match?(/\A!\s*\S/) }) { |text| shell(text) }
       registry.register(CONTINUE_COMMAND, "answer the continue offer (yes, no or no, <reason>)") do |text|
         next reply("nothing to continue") unless @turn_flow.awaiting_continue?
 
         answer = text.delete_prefix(CONTINUE_COMMAND).strip
         continue_answer(answer.empty? ? CONTINUE_COMMAND : answer)
       end
-      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)") do |text|
+      # It reads the hosts only (the registry is mutex-guarded): mid-turn too.
+      registry.register(MODELS_COMMAND, "list the hosts' models (/models <text> filters)",
+                        mid_turn: ->(_text) { :anytime }) do |text|
         reply(models_listing(text.delete_prefix(MODELS_COMMAND).strip))
       end
-      registry.register(GUARDRAILS_COMMAND, "list the guardrail rules and approvals (/guardrails revoke N)") do |text|
+      registry.register(GUARDRAILS_COMMAND, "list the guardrail rules and approvals (/guardrails revoke N)",
+                        mid_turn: show_mid_turn(GUARDRAILS_COMMAND)) do |text|
         guardrails(text.delete_prefix(GUARDRAILS_COMMAND).strip)
       end
       # It only reads the store: mid-turn too.
@@ -74,11 +84,11 @@ module Samagotchi
                                                                                    match: ->(text) { text.casecmp?(CONTEXT_COMMAND) }) do |_text|
         reply(context_listing)
       end
-      registry.register(MODEL_COMMAND, "show or switch the model",
+      registry.register(MODEL_COMMAND, "show or switch the model", mid_turn: show_mid_turn(MODEL_COMMAND),
                         match: ->(text) { text.match?(%r{\A/model(?:\s+.*)?\z}) }) { |text| model(text) }
-      # Not anytime: it saves the session; it takes effect at the next turn's start.
+      # Setting it saves the session; it takes effect at the next turn's start.
       registry.register(LLM_CONTEXT_COMMAND, "show or set this session's LLM context strategy, apply rule and budget",
-                        id: :llm_context, match: ->(text) { text.match?(%r{\A/llm-context(?:\s+.*)?\z}) }) { |text| llm_context(text) }
+                        id: :llm_context, mid_turn: show_mid_turn(LLM_CONTEXT_COMMAND), match: ->(text) { text.match?(%r{\A/llm-context(?:\s+.*)?\z}) }) { |text| llm_context(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
@@ -94,6 +104,13 @@ module Samagotchi
       registry
     end
 
+    # @return [#call] line → :anytime for +name+ alone (it shows), else
+    #   :queue (it sets what the next turn runs under)
+    def self.show_mid_turn(name)
+      ->(text) { text == name ? :anytime : :queue }
+    end
+    private_class_method :show_mid_turn
+
     # @param word [String] the regexp source of the exit word
     def self.exit_match(word)
       pattern = /\A#{word}(?:\s+#{EXIT_DELETE_FLAG})?\z/i
@@ -149,7 +166,7 @@ module Samagotchi
       lines = entries.map do |entry|
         notes = []
         notes << entry.source unless entry.source == "core"
-        notes << "mid-turn too" if entry.anytime
+        notes << MID_TURN_NOTES[entry.mid_turn_label] if MID_TURN_NOTES[entry.mid_turn_label]
         notes << (entry.uis ? "#{entry.uis.join(" and ")} only" : "terminal only") if entry.local
         line = "  #{self.class.display_name(entry).ljust(width)}  #{entry.description}"
         notes.empty? ? line : "#{line}  (#{notes.join("; ")})"

data/lib/samagotchi/session_manager.rb

@@ -12,6 +12,8 @@ require_relative "config"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "session_metrics"
+require_relative "llm_context_strategy"
+require_relative "host_registry"
 require_relative "utf8_default"
 require_relative "turn_note"
 require_relative "owner_lock"
@@ -290,6 +292,10 @@ module Samagotchi
       sd = state_dir || Session.default_state_dir
       root = cwd && folder_path(cwd)
       roots = {}
+      # One registry per listing, built only when a row has a saved context
+      # to count: its session's llm_context budget is what ctx_pct counts
+      # against (SessionMetrics.saved_context_pct).
+      budgets = listing_budgets
       summaries = Session.list(state_dir: sd, sort: sort || "updated_at", order: order || "desc", project_root: project_root,
                                include_archived: include_archived).lazy
                          .reject { |s| (!include_tests && s.test_run) || s.id == exclude }
@@ -302,7 +308,8 @@ module Samagotchi
         { id: s.id, short_id: s.id[0, 8], desc: summary_desc(s), preview: summary_preview(s), cwd: s.working_directory,
           project: s.project_root(cache: roots), updated_at: s.updated_at, status: s.status, live: owned, busy: owned && s.status == Session::STATUS_RUNNING,
           owner: owner&.kind, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
-          ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd))&.round(1),
+          ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd),
+                                                    budget_tokens: -> { budgets.call(s) })&.round(1),
           parent_id: s.parent_id, parent_short_id: s.parent_id&.[](0, 8), delegate: s.delegate?, archived: s.archived,
           scratch: s.scratch, test_run: s.test_run, stopped_by: s.stopped_by }.merge(waiting_fields(s.waiting_question(live: owned)))
       end
@@ -316,6 +323,17 @@ module Samagotchi
     end
     private_class_method :waiting_fields
 
+    # One HostRegistry for a whole listing, built on the first row that
+    # needs it (a saved context to count) and kept for the rest: resolving a
+    # session's llm_context budget reads config.yml (mtime-cached), so not
+    # one registry per row.
+    # @return [#call] (session) -> the session's budget in tokens or nil
+    def self.listing_budgets
+      registry = nil
+      ->(session) { LLMContextStrategy.session_budget(session, registry: registry ||= HostRegistry.new) }
+    end
+    private_class_method :listing_budgets
+
     # The sessions delegated by +parent_id+ (the `delegate` tool), newest
     # first, as .session_summaries rows. A running one (busy) counts against
     # session.max_children. Archived ones too.

data/lib/samagotchi/session_metrics.rb

@@ -141,22 +141,29 @@ module Samagotchi
     # its saved analytics.json: a percentage, or nil when the file, the count
     # or the window is missing (the session lists read it per row).
     # @param session_dir [String]
+    # @param budget_tokens [Integer, Proc, nil] the session's LLM context
+    #   budget; a positive one smaller than the window is what the fill is
+    #   counted against (the live meter counts the same way,
+    #   ContextStatus#counted_against). nil or 0: the window. A callable is
+    #   resolved only when there is a context to count, so a caller can build
+    #   a registry lazily.
     # @return [Float, nil]
-    def self.saved_context_pct(session_dir)
-      saved_summary(session_dir)&.ctx_pct
+    def self.saved_context_pct(session_dir, budget_tokens: nil)
+      saved_summary(session_dir, budget_tokens: budget_tokens)&.ctx_pct
     end
 
     # The context's fill and the token totals from the session's saved
     # analytics.json, read once; nil without a readable file.
     # @param session_dir [String]
+    # @param budget_tokens [Integer, Proc, nil] see .saved_context_pct
     # @return [SavedSummary, nil]
-    def self.saved_summary(session_dir)
+    def self.saved_summary(session_dir, budget_tokens: nil)
       data = JSON.parse(File.read(File.join(session_dir, "analytics.json")))
       return nil unless data.is_a?(Hash)
 
       tokens = data["tokens"].is_a?(Hash) ? data["tokens"] : {}
       count = ->(key) { tokens[key].is_a?(Numeric) ? tokens[key] : 0 }
-      SavedSummary.new(ctx_pct: saved_pct(data["context"]), prompt_sum: count.call("prompt_sum"),
+      SavedSummary.new(ctx_pct: saved_pct(data["context"], budget_tokens), prompt_sum: count.call("prompt_sum"),
                        completion_sum: count.call("completion_sum"), cached_sum: count.call("cached_sum"),
                        reasoning_sum: count.call("reasoning_sum"), cost_sum: count.call("cost_sum"),
                        memory_index: data["memory_index"].is_a?(Hash) ? data["memory_index"] : nil)
@@ -164,15 +171,25 @@ module Samagotchi
       nil
     end
 
-    def self.saved_pct(context)
+    def self.saved_pct(context, budget_tokens)
       return nil unless context.is_a?(Hash)
 
       used = context["used_tokens"]
       window = context["window_tokens"]
       return nil unless used.is_a?(Numeric) && window.is_a?(Numeric) && window.positive?
 
-      used * 100.0 / window
+      used * 100.0 / counted_against(budget_tokens, window)
     end
+
+    # What the saved fill counts against: the window, or the budget when one
+    # is set and smaller (ContextStatus#counted_against, the live meter's
+    # rule). The budget is resolved here, not by the caller, so a caller
+    # that builds one lazily doesn't build it for a row with no context.
+    def self.counted_against(budget_tokens, window_tokens)
+      budget = budget_tokens.respond_to?(:call) ? budget_tokens.call : budget_tokens
+      budget.is_a?(Numeric) && budget.positive? ? [budget, window_tokens].min : window_tokens
+    end
+    private_class_method :counted_against
     private_class_method :saved_pct
 
     # One turn's tool records from the session's saved analytics.json, in
@@ -192,6 +209,22 @@ module Samagotchi
       []
     end
 
+    # One turn's saved record from the session's analytics.json, string-keyed
+    # as saved: what a join replays the turn's failure (or cancel) line from.
+    # nil without a turn id (an older session's prompt), the file, records,
+    # or a record for the turn.
+    # @param session_dir [String]
+    # @param turn_id [String, nil]
+    # @return [Hash, nil]
+    def self.saved_turn_record(session_dir, turn_id)
+      return nil if turn_id.to_s.empty?
+
+      records = JSON.parse(File.read(File.join(session_dir, "analytics.json")))["turn_records"]
+      Array(records).find { |r| r.is_a?(Hash) && r["id"] == turn_id }
+    rescue JSON::ParserError, SystemCallError, TypeError
+      nil
+    end
+
     # "ctx 12%" for the session lists, "" when unknown.
     # @param pct [Float, nil]
     # @return [String]

data/lib/samagotchi/sessions_command.rb

@@ -226,14 +226,24 @@ module Samagotchi
         recap = Samagotchi::RecapStore.preview(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
         (recap || Samagotchi::SessionManager.summary_text(s))[0, 60]
       end
+      # How full the context was after the last turn: "ctx 12%", counted
+      # against the session's llm_context budget when one is set and smaller
+      # than the window, as the live meter counts it (one registry for the
+      # whole table, built when the first row has a saved context). Blank when
+      # unknown.
+      budgets = nil
+      ctx = lambda do |s|
+        Samagotchi::SessionMetrics.context_label(
+          Samagotchi::SessionMetrics.saved_context_pct(
+            Samagotchi::Session.session_dir(s.id, state_dir: state_dir),
+            budget_tokens: -> { Samagotchi::LLMContextStrategy.session_budget(s, registry: budgets ||= Samagotchi::HostRegistry.new) }
+          )
+        )
+      end
       # A delegated session points at its parent: ↳ <parent's short id>.
       row = lambda do |s|
         flag = session_flag(scratch: s.scratch, test_run: s.test_run, archived: s.archived, stopped_by: s.stopped_by)
         child = s.parent_id ? "  ↳ #{s.parent_id[0, 8]}" : ""
-        # How full the context was after the last turn: "ctx 12%", blank when unknown.
-        ctx = Samagotchi::SessionMetrics.context_label(
-          Samagotchi::SessionMetrics.saved_context_pct(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
-        )
         # 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)
         waiting = s.waiting_question(live: !!live)
@@ -241,7 +251,7 @@ module Samagotchi
                  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}"
+        "#{s.id}  #{status.ljust(8)}  #{ctx.call(s).ljust(8)}  #{s.updated_at}  #{list_text.call(s)}#{flag}#{child}"
       end
       if project
         sessions.each { |s| @stdout.puts row.call(s) }

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -126,6 +126,10 @@ module Samagotchi
         @early_lines = []
         @question = nil
         @answered_ids = Set.new
+        # Commands queued for after the running turn, any UI's: a /archive
+        # typed during the turn waits for them too (#archive_due?).
+        @queued_ids = Set.new
+        @archive_after_turn = false
         @reader = nil
         @first_prompt = first_prompt
         @first_commands = Array(first_command)
@@ -188,6 +192,7 @@ module Samagotchi
           when :event
             ended = safely_handle(payload)
             return ended if %i[closed failed unanswered].include?(ended)
+            return archive_now if archive_due?
 
             ended = take_early_lines
             return ended if ended
@@ -264,9 +269,11 @@ module Samagotchi
         when :answer_display then @display_pending = false
         when :context_status, :used_memories_updated then @status.take_event(event)
         # Another client's anytime command: its line now, before the cards
-        # it shows (its command_ran comes when it's done).
+        # it shows (its command_ran comes when it's done). One queued for
+        # after the turn says so now.
         when :command_queued
           @screen.commit(prompt_line(event[:client_id], event[:line])) if event[:anytime] && !own?(event[:client_id]) && !event[:card]
+          command_waits(event) if event[:waits] && !event[:card]
         when :command_ran
           command_ran(event)
           return first_command_ran(event) if @first_command_id && event[:command_id] == @first_command_id
@@ -379,6 +386,7 @@ module Samagotchi
         local = command_registry.lookup_local(text)&.id
         return submit(nil) if local == :detach
         return SessionCommands.delete_on_exit?(text) ? exit_and_delete : exit_worker if local == :exit
+        return archive_after_turn if local == :archive && (@running || !@queued_ids.empty?)
         return exit_and_archive if local == :archive
 
         if @continue_offer
@@ -446,6 +454,24 @@ module Samagotchi
         detach("Detached; the worker is stopping, but session #{id} was not deleted (#{e.message}): chi sessions delete #{id}")
       end
 
+      # /archive during a turn (D2): it waits for the turn's end and the
+      # commands queued behind it (#archive_due?), then runs.
+      # @return [nil]
+      def archive_after_turn
+        @archive_after_turn = true
+        @screen.commit("(archives after this turn)")
+        nil
+      end
+
+      def archive_due? = @archive_after_turn && !@running && @queued_ids.empty?
+
+      # @return [Symbol] :detached
+      def archive_now
+        @archive_after_turn = false
+        exit_and_archive
+        :detached
+      end
+
       # /archive: the worker is asked to exit as for /exit, then the session
       # is archived. A worker staying up for another UI (or reminders) is
       # stopped by the archive, as the web's archive stops it; a turn
@@ -546,13 +572,36 @@ module Samagotchi
         "worker unreachable: #{head.downcase}"
       end
 
+      QUEUED_NOTE = "(queued: runs after this turn)"
+
+      # A command queued for after the running turn (command_queued with
+      # waits): its line now (another client's) and a note; its command_ran
+      # has no line again (queued: true).
+      def command_waits(event)
+        @queued_ids << event[:command_id]
+        if own?(event[:client_id])
+          first = event[:command_id] == @first_command_id
+          return @screen.commit(first ? first_command_queued : QUEUED_NOTE)
+        end
+
+        @screen.commit("#{prompt_line(event[:client_id], event[:line])} #{QUEUED_NOTE}")
+      end
+
+      def first_command_queued
+        flag = @first_command_line.to_s.start_with?("/model") ? "--model" : "--llm-context"
+        "(#{flag} queued: applies after the running turn)"
+      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]
+        @queued_ids.delete(event[:command_id])
+        unless own?(event[:client_id]) || event[:anytime] || event[:card] || event[:queued]
+          @screen.commit(prompt_line(event[:client_id], event[:line]))
+        end
         output = event[:output].to_s
         if output.empty?
           nil
-        elsif event[:status] == "busy" || PromptHistory.shell_line?(event[:line])
+        elsif %w[busy dropped].include?(event[:status]) || PromptHistory.shell_line?(event[:line])
           @screen.commit(output)
           put_back_busy_command(event) if event[:status] == "busy"
         else
@@ -992,6 +1041,14 @@ module Samagotchi
           @shown_enqueued << entry[:enqueued_id]
           @screen.commit("queued #{prompt_line(entry[:client_id], entry[:prompt])}")
         end
+        # Commands waiting for the turn's end (their command_ran prints no
+        # line); a resync prints only the ones it hadn't shown.
+        shown = @queued_ids.dup
+        @queued_ids.clear
+        Array(snapshot[:queued_commands]).each do |entry|
+          @queued_ids << entry[:command_id]
+          @screen.commit("queued #{prompt_line(entry[:client_id], entry[:line])}") unless shown.include?(entry[:command_id])
+        end
         return send_first_command unless @first_commands.empty?
 
         send_first_prompt
@@ -1076,10 +1133,18 @@ module Samagotchi
         Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         from = messages.index { |m| m.equal?(exchange[last_user]) }
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
+        failed = join_failed_record(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"]))
+        elsif failed
+          # A failed turn whose steps stayed: the line the live view left,
+          # and no step text as if it were the answer (the web keeps a
+          # failed turn's texts as steps too).
+          failure = failed["failure"]
+          @screen.commit(@view.turn_failed_line(failure["summary"] || failure["message"], failed["duration_ms"]))
+          @screen.commit(@view.turn_end_hint(ROLLBACK_HINT)) if failure["kept_steps"]
         else
           # The saved answer is raw: the latest keeps its thinking, and one may
           # be only a tool call.
@@ -1119,6 +1184,23 @@ module Samagotchi
         []
       end
 
+      # The turn's saved record when it failed with the fields its line is
+      # made of (SessionMetrics#failure_fields), else nil: a completed,
+      # canceled or older turn — or one saved before the failure field —
+      # draws its answer as before.
+      def join_failed_record(prompt)
+        record = SessionMetrics.saved_turn_record(Session.session_dir(@client.session_id),
+                                                  prompt[:turn_id] || prompt["turn_id"])
+        return nil unless record && record["status"] == "failed" && record["failure"].is_a?(Hash)
+
+        failure = record["failure"]
+        return nil if failure["summary"].to_s.empty? && failure["message"].to_s.empty?
+
+        record
+      rescue Session::InvalidId
+        nil
+      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.
@@ -1222,7 +1304,8 @@ module Samagotchi
           # hook's notice, a retry's line), as they were drawn live.
           # Questions are left out: the pending one is asked after the
           # replay, answered ones showed no line.
-          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut then @renderer.call(event)
+          when :turn_started, :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
+            @renderer.call(event)
           end
         end
         @view.resume(tail: tail, lane: lane, tool: running_tool, parts: turn[:parts])

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -83,6 +83,9 @@ module Samagotchi
         when :steer_cut
           @view.finish_thinking_spinner
           @view.print_line(@view.format_steer_cut_line(event))
+        when :llm_context_edited
+          @view.finish_thinking_spinner
+          @view.print_line(@view.format_llm_context_line(event))
         when :turn_completed
           render_turn_summary(event[:turn_summary]) if event[:turn_summary]
         when :turn_canceled