samagotchi 0.46.0 → 0.47.0

data/lib/samagotchi/engine.rb

@@ -945,6 +945,8 @@ module Samagotchi
     # context window, the served model and (on a native host) the prompt
     # profile come from the effective model's server, so this may make one
     # short /props GET; the cheap #session_state_snapshot never does.
+    # price_host: the effective model's host, whose hosts.<name>.models
+    # prices the cost estimate names.
     # @return [Hash] @metrics.snapshot, filled in
     def stats_snapshot
       snapshot = @metrics.snapshot
@@ -952,7 +954,7 @@ module Samagotchi
       served, served_for = served_model_for(snapshot, target: target)
       snapshot = snapshot.merge(served_model: served, served_model_for: served_for,
                                 served_expected_by: served_expected_by(served, target: target), llm_context: llm_context_summary,
-                                prompt_notes: prompt_notes.map(&:to_h))
+                                prompt_notes: prompt_notes.map(&:to_h), price_host: target.entry.name)
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
         if window
@@ -1051,8 +1053,7 @@ module Samagotchi
     # warn about. nil when none does.
     # @return [String, nil]
     def served_expected_by(served, target: nil)
-      target ||= @host_registry.resolve(@effective_model_name)
-      target.entry.name if target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.serves?(served)
+      ServedModel.expected_by(target || @host_registry.resolve(@effective_model_name), served)
     rescue StandardError
       nil
     end
@@ -1447,8 +1448,6 @@ module Samagotchi
       @question_desk.request(payload)
     end
 
-    QUESTION_DISMISSED_NOTE = QuestionDesk::DISMISSED_NOTE
-
     # Open a question for the UIs and wait for its answer
     # (QuestionDesk#open_question: BLOCKS until answered or cancelled).
     # @param fields [Hash] question:, options:, header:, multi_select:, allow_freeform:, …

data/lib/samagotchi/host_model.rb

@@ -78,18 +78,22 @@ module Samagotchi
     # One host's rows as the listings show them, declared ids first, then
     # the listed ones in the host's order (see Row). An id both declared and
     # listed is one row. Pure: +results+ (list_all_models') is only read.
-    # A host that errored has no rows: its declared ids aren't shown
-    # either (the listings say it's unreachable).
+    # A host that errored keeps only its declared ids, marked unavailable
+    # (still pickable; the listings warn it's unreachable); [] when it
+    # declares none.
     # @param results [Hash{String => Hash}] host name => {models: [ModelInfo], error:}
     # @param entries [Hash{String => HostRegistry::HostEntry}]
-    # @return [Hash{String => Array<Row>}] for the hosts that answered
+    # @return [Hash{String => Array<Row>}] for every host in +results+
     def self.rows(results, entries)
       results.each_with_object({}) do |(name, data), out|
-        next if data[:error]
+        declared = entries[name]&.models || {}
+        if data[:error]
+          out[name] = declared.values.map { |m| HostModel::Row.new(id: m.id, configured: true, info: nil, unavailable: true) }
+          next
+        end
 
         infos = Array(data[:models])
         by_id = infos.group_by { |info| info.id.to_s.downcase }
-        declared = entries[name]&.models || {}
         out[name] = declared.values.map do |m|
           info = by_id[m.id.downcase]&.first
           # A listed id keeps the host's spelling: a case-sensitive server takes only that.
@@ -111,6 +115,9 @@ module Samagotchi
   # A listing row (HostModel.rows): id as the host lists it, else as
   # declared;
   # configured: declared under hosts.<name>.models; info: the host's
-  # ModelInfo for it, nil when only declared.
-  HostModel::Row = Data.define(:id, :configured, :info)
+  # ModelInfo for it, nil when only declared; unavailable: the host failed
+  # to list its models; only its declared ids are shown.
+  HostModel::Row = Data.define(:id, :configured, :info, :unavailable) do
+    def initialize(id:, configured:, info:, unavailable: false) = super
+  end
 end

data/lib/samagotchi/host_registry.rb

@@ -322,7 +322,7 @@ module Samagotchi
             save_model_list(name, models)
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
-            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: e.message }
+            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: list_error(e) }
           end
           results_mutex.synchronize { results[name] = data }
         end
@@ -374,6 +374,11 @@ module Samagotchi
 
     private
 
+    # A listing error as text without the host's name (a provider error's
+    # #detail: "connection refused", "request failed after …"): every line
+    # that shows it names the host itself.
+    def list_error(error) = error.is_a?(LLM::ProviderError) ? error.detail : error.message
+
     # Save a host's just-listed models on disk, for the processes that spawn
     # a worker without listing (`chi send --new --model`, delegate):
     # ModelListStore is what they check an id against.

data/lib/samagotchi/llm/chat_loop.rb

@@ -510,15 +510,18 @@ module Samagotchi
           generation_controller = nil
           response = with_generation do |controller|
             generation_controller = controller
+            # One count for the step: the ask-again without thinking fields
+            # doesn't get drops of its own.
+            drops = DropCount.new(0, 0)
             begin
-              request_with_drops(iteration, retry_generation, streamed, thought, 0, controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
             rescue BadRequest => e
               raise unless thinking_refused?(e)
 
               # Once per model: asked again without the thinking fields.
               @loop.thinking_refused!(@model_name)
               emit(type: :thinking_refused, iteration: iteration, model: @model_name, level: @loop.thinking, detail: e.detail)
-              request_with_drops(iteration, retry_generation, streamed, thought, 0, controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
             end
           rescue RequestCancelled
             raise unless generation_controller&.cancelled? && !@cancel_controller.cancelled?
@@ -596,9 +599,14 @@ module Samagotchi
         # retries.
         MAX_STREAM_DROPS = 2
 
-        # Runs one request, asking again on a mid-stream drop. +attempt+
-        # counts the drops already retried this step.
-        def request_with_drops(iteration, retry_generation, streamed, thought, attempt, generation_controller)
+        # A step's drops asked again (+drops+) and the HTTP requests made so
+        # far (+requests+: each failed request's transport attempts), so the
+        # error that ends the step counts every request, not the last one's.
+        DropCount = Struct.new(:drops, :requests)
+
+        # Runs one request, asking again on a mid-stream drop; +count+ (a
+        # DropCount) carries on across calls for one step.
+        def request_with_drops(iteration, retry_generation, streamed, thought, count, generation_controller)
           streamed_any = false
           request(iteration, retry_generation, streamed, thought, generation_controller, -> { streamed_any = true })
         rescue RetryExhausted => e
@@ -607,10 +615,16 @@ module Samagotchi
           cancelled = [@cancel_controller, generation_controller].compact.find(&:cancelled?)
           raise RequestCancelled, cancelled.reason if cancelled
 
+          count.requests += e.attempts.to_i
           limit = @loop.stream_drop_limit(MAX_STREAM_DROPS)
-          raise if attempt >= limit || !streamed_any
+          if count.drops >= limit || !streamed_any
+            raise if count.requests == e.attempts.to_i
+
+            raise RetryExhausted.new(attempts: count.requests, last_error: e.last_error, label: e.host)
+          end
 
-          attempt += 1
+          count.drops += 1
+          attempt = count.drops
           streamed.clear
           thought.clear
           delay = @loop.generation_retry_delay(attempt)
@@ -620,6 +634,12 @@ module Samagotchi
                next_delay: delay, error_class: e.class.name, error_message: e.message, status: nil, restarted: true)
           @loop.wait_retry(delay, @cancel_controller, generation_controller)
           retry
+        rescue ProviderError => e
+          # Another failure (a 503, a refusal) after earlier requests this
+          # step: its count takes theirs in.
+          count.requests += e.attempts.to_i
+          e.attempts = count.requests
+          raise
         end
 
         # A 400 about reasoning, for a request that carried thinking fields

data/lib/samagotchi/llm/errors.rb

@@ -223,11 +223,17 @@ module Samagotchi
 
       def initialize(attempts:, last_error:, label: "llama.cpp")
         @last_error = last_error
-        super("#{label} request failed after #{attempts} attempts: #{last_error.class}: #{last_error.message}",
+        super("#{label} request failed after #{self.class.count(attempts)}: #{last_error.class}: #{last_error.message}",
               host: label, retryable: false, attempts: attempts)
       end
 
-      def summary = "network error after #{attempts} attempts (host #{host}: #{last_error.class})"
+      def summary = "network error after #{self.class.count(attempts)} (host #{host}: #{last_error.class})"
+
+      # The message without its leading "host ": "request failed after …".
+      def detail = host ? message.delete_prefix("#{host} ") : message
+
+      # "1 attempt", "3 attempts".
+      def self.count(attempts) = "#{attempts} attempt#{"s" unless attempts == 1}"
     end
 
     # A refused connection: nothing listens at the host's address. Not

data/lib/samagotchi/llm_context_strategy.rb

@@ -181,6 +181,7 @@ module Samagotchi
       return nil if session.nil?
 
       require_relative "config"
+      require_relative "model_profile"
       registry ||= begin
         require_relative "host_registry"
         HostRegistry.new

data/lib/samagotchi/model_catalog.rb

@@ -9,13 +9,14 @@ module Samagotchi
   module ModelCatalog
     # host: the host that listed (or declares) the id; ref: the name
     # `--model` takes for it (see .spell); configured: declared under
-    # hosts.<name>.models (HostModel.rows).
-    Row = Data.define(:host, :id, :ref, :configured) do
-      def initialize(host:, id:, ref:, configured: false) = super
+    # hosts.<name>.models (HostModel.rows); unavailable: a declared id of a
+    # host that failed to list its models (still pickable).
+    Row = Data.define(:host, :id, :ref, :configured, :unavailable) do
+      def initialize(host:, id:, ref:, configured: false, unavailable: false) = super
     end
     # rows: the default host's first, then the others by name, each host's
-    # declared ids first (HostModel.rows); warnings:
-    # "host: error" per host that failed.
+    # declared ids first (HostModel.rows; a host that failed keeps only
+    # those); warnings: "host: error" per host that failed.
     Listing = Data.define(:rows, :warnings)
 
     module_function
@@ -29,15 +30,13 @@ module Samagotchi
       warnings = []
       host_rows = HostModel.rows(results, registry.entries)
       results.keys.sort_by { |name| [name == default_host ? 0 : 1, name] }.each do |host|
-        if results[host][:error]
-          warnings << "#{host}: #{results[host][:error]}"
-          next
-        end
-        host_rows[host].each do |row|
+        warnings << "#{host}: #{results[host][:error]}" if results[host][:error]
+        host_rows.fetch(host, []).each do |row|
           id = row.id
           next if id.strip.empty? || (!row.configured && id.end_with?(":batch"))
 
-          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host), configured: row.configured)
+          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host), configured: row.configured,
+                          unavailable: row.unavailable)
         end
       end
       Listing.new(rows: rows, warnings: warnings)
@@ -55,7 +54,8 @@ module Samagotchi
     # go first (its rows are the "default host" group). default: the default's listed
     # row name when it resolves to one, else its resolved ref; default_typed:
     # the alias it was typed as. A row whose name resolves elsewhere (an
-    # alias named like the id shadows it) carries shadowed_by.
+    # alias named like the id shadows it) carries shadowed_by; a declared id
+    # of a host that failed to list carries unavailable.
     # @param default_name [String, nil] default.model as configured
     # @return [Hash]
     def payload(results, registry:, default_name:)
@@ -63,6 +63,7 @@ module Samagotchi
       models = listing.rows.map do |row|
         hash = { name: row.ref, host: row.host, id: row.id }
         hash[:configured] = true if row.configured
+        hash[:unavailable] = true if row.unavailable
         shadow = shadowed_by(row, registry)
         shadow ? hash.merge(shadowed_by: shadow) : hash
       end

data/lib/samagotchi/model_profile.rb

@@ -232,10 +232,11 @@ module Samagotchi
       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).
+      # A re-list that answered: the saved list catches up. The default
+      # re-list, HostRegistry#list_models, saved it already; a given one
+      # is saved here.
       if fresh_ids
-        Samagotchi::ModelListStore.save(host, fresh_ids, env: env)
+        Samagotchi::ModelListStore.save(host, fresh_ids, env: env) if relist
         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)

data/lib/samagotchi/models_command.rb

@@ -23,13 +23,14 @@ module Samagotchi
         Lists the models every configured host offers, as the names
         --model takes: the default first, a default-host id bare, another
         host's as host:id, then the aliases as "name -> ref". A host that
-        fails or doesn't answer in time is noted on stderr.
+        fails or doesn't answer in time is noted on stderr; the ids
+        declared under its hosts.<name>.models are still listed.
         TEXT          only the names containing it (any case)
         --format json the default, the models (host, id, name), the aliases
                       and the warnings as one JSON object
         --timeout S   wait at most S seconds for the hosts; default 4
         Exit 0 when any host listed its models, 1 when none did (the
-        default is still printed), 2 on a usage error.
+        default and declared names still print), 2 on a usage error.
     TEXT
 
     FLAGS = CLI::Flags.new(help: CLI::Command::HELP_WORDS) do |f|
@@ -59,8 +60,10 @@ module Samagotchi
       return usage_error("--timeout takes a number of seconds above 0") unless timeout&.positive?
 
       payload, listed = catalog(timeout)
+      # Before the filter: a down host's declared ids are listed even when TEXT hides them.
+      down_hosts = payload[:models].select { |m| m[:unavailable] }.map { |m| m[:host] }.uniq
       payload = filtered(payload, parsed.args.join(" ").strip)
-      options[:format] == "json" ? print_json(payload) : print_text(payload)
+      options[:format] == "json" ? print_json(payload) : print_text(payload, down_hosts)
       listed ? 0 : 1
     end
 
@@ -99,14 +102,18 @@ module Samagotchi
       @stdout.puts(JSON.generate(payload.except(:filter)))
     end
 
-    def print_text(payload)
+    # @param down_hosts [Array<String>] hosts that failed but declare ids
+    def print_text(payload, down_hosts)
       default = payload[:default]
       names = payload[:models].reject { |m| m[:shadowed_by] }.map { |m| m[:name] }
       shown_default = default && (payload[:filter].nil? || default.downcase.include?(payload[:filter].downcase))
       @stdout.puts(default) if shown_default
       (names - [default]).each { |name| @stdout.puts(name) }
       payload[:aliases].each { |a| @stdout.puts("#{a[:name]} -> #{a[:ref]}") }
-      payload[:warnings].each { |w| @stderr.puts("chi models: #{w}") }
+      payload[:warnings].each do |w|
+        kept = down_hosts.any? { |host| w.start_with?("#{host}: ") }
+        @stderr.puts("chi models: #{w}#{" (its declared ids are still listed)" if kept}")
+      end
     end
   end
 end

data/lib/samagotchi/question_desk.rb

@@ -64,6 +64,13 @@ module Samagotchi
                      "or anything else that changes files or state. Finish your reply with what you found " \
                      "and what you would do, and wait."
 
+    # The cancel reason of a question no one could answer: a
+    # --non-interactive run has no one to ask (TerminalUI).
+    UNANSWERABLE_REASON = "non_interactive"
+    UNANSWERABLE_NOTE = "No one could answer the question: this is a non-interactive run. Don't do what you " \
+                        "asked about, or anything else that changes files or state. Finish your reply with " \
+                        "what you found and what you would do."
+
     # @param session           [#call] → Session, nil
     # @param state_dir         [#call] → String, the session's state dir
     # @param emit              [#call] (event) → emits an event to the turn sink + observers
@@ -82,6 +89,8 @@ module Samagotchi
       @cv = @lock.new_cond
       @pending = nil
       @answer = nil
+      # Why the open question was cancelled (#cancel), for the sync path.
+      @cancel_reason = nil
       @sync_handler = nil
       # The standing question while it is @pending: {id:, fields:,
       # on_answer:, on_superseded_close:}; @shelved, one superseded by (or
@@ -106,7 +115,10 @@ module Samagotchi
                                     .merge(multi_select: !!payload[:multi_select], allow_freeform: !!payload[:allow_freeform]))
       # Dismissed (the card's dismiss, Esc): an answer of its own, not a
       # tool failure the model learns to avoid the tool from.
-      result = { dismissed: true, id: result[:id], note: DISMISSED_NOTE } if result.is_a?(Hash) && result[:error] == "no answer"
+      if result.is_a?(Hash) && result[:error] == "no answer"
+        note = result[:reason] == UNANSWERABLE_REASON ? UNANSWERABLE_NOTE : DISMISSED_NOTE
+        result = { dismissed: true, id: result[:id], note: note }
+      end
       # Who answered is for the relay, not the model's tool result.
       result = result.except(:by) if result.is_a?(Hash)
       result.is_a?(String) ? result : JSON.generate(result)
@@ -213,7 +225,15 @@ module Samagotchi
             emit({ type: :question_answered, id: id, answer: ans })
             return ans
           end
-          return sync_res if sync_res.is_a?(String) && !sync_res.strip.empty?
+          if sync_res.is_a?(String) && !sync_res.strip.empty?
+            # The handler's text is the answer: nothing stays pending, and
+            # every UI hears it was answered (the text as its freeform).
+            @lock.synchronize { @pending = nil }
+            clear_saved_question
+            emit({ type: :question_answered, id: id,
+                   answer: { id: id.to_s, selected: [], freeform: sync_res.strip, selected_indices: [] } })
+            return sync_res
+          end
         rescue StandardError => e
           Log.warn(:turn, "question_handler_failed", echo: "[ask_user_question] sync handler failed: #{e.message}", error: e.class.name)
         end
@@ -221,9 +241,12 @@ module Samagotchi
         # CV (no cross-thread answerer exists for synchronous UIs). Clear pending
         # and return an error so the model can fallback to plain text. Generic
         # observers will discard the stale question_requested via staleness check.
-        @lock.synchronize { @pending = nil }
+        reason = @lock.synchronize do
+          @pending = nil
+          @cancel_reason
+        end
         clear_saved_question
-        return { error: "no answer", detail: "handler failed to capture selection", id: id }
+        return { error: "no answer", detail: "handler failed to capture selection", id: id, reason: reason }.compact
       end
 
       # Block until answered/cancelled (cross-thread path: WEB/Bridge/background worker)
@@ -356,6 +379,7 @@ module Samagotchi
         next if @standing
 
         pending[:status] = "cancelled"
+        @cancel_reason = reason.to_s
         @cv.broadcast
         pending[:id]
       end
@@ -403,6 +427,7 @@ module Samagotchi
       @lock.synchronize do
         @pending = pending
         @answer = nil
+        @cancel_reason = nil
         @standing = standing&.merge(id: pending[:id])
       end
       if session

data/lib/samagotchi/send_command.rb

@@ -4,6 +4,7 @@ require_relative "client_id"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "session_manager"
+require_relative "session_chain"
 require_relative "context_quote"
 require_relative "reply_wait"
 require_relative "parent_report"
@@ -34,6 +35,7 @@ module Samagotchi
     USAGE = <<~TEXT
       Usage: chi send [-m TEXT] [--image PATH]... (ID|PREFIX)...
              chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [-m TEXT] [--image PATH]...
+             chi send --new --continues (ID|PREFIX|last:ID) [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
              chi send --wait [--timeout S] [--format json] ID
         Sends a message to each session, as if typed in it: a turn starts,
@@ -52,6 +54,14 @@ module Samagotchi
                     web does, and print its id
         --dir DIR   (--new) its folder, the project it belongs to; default
                     the current one
+        --continues ID
+                    (--new) start the next link of that session's chain:
+                    in its folder, on its model and LLM context, with a
+                    note carrying its recap; it is archived. last:ID
+                    names the chain's latest link. Without -m the new
+                    session waits idle. Refused for a session continued
+                    already (naming the next link) or with delegates
+                    still open
         --model M   (--new) its model; default the configured one
         --llm-context LAYERS, --llm-context-apply RULE, --llm-context-budget N
                     (--new) its own LLM context strategy (none, stale,forget),
@@ -83,6 +93,7 @@ module Samagotchi
       f.value "-m", "--message"
       f.switch "--new"
       f.value "--dir"
+      f.value "--continues"
       f.value "--model"
       f.value "--llm-context", key: :llm_strategy
       f.value "--llm-context-apply", key: :llm_apply
@@ -152,10 +163,14 @@ module Samagotchi
       # Before the wait-only case, which would drop the images.
       return usage_error("--image needs a message: pass -m TEXT or pipe it in") if prompt.nil? && !options[:images].empty?
       return run_wait_only(options) if prompt.nil? && options[:wait] && !options[:new]
-      return usage_error("no message: pass -m TEXT or pipe it in") unless prompt
+
+      # The next link of a chain may start idle, waiting for its first message.
+      idle_link = prompt.nil? && options[:continues]
+      return usage_error("--wait needs a message to wait for: pass -m TEXT") if idle_link && options[:wait]
+      return usage_error("no message: pass -m TEXT or pipe it in") unless prompt || idle_link
 
       begin
-        prompt = SessionInbox.checked_text(prompt, noun: "message")
+        prompt &&= SessionInbox.checked_text(prompt, noun: "message")
       rescue SessionInbox::NoteRejected => e
         @stderr.puts("chi send: #{e.message}")
         return 1
@@ -205,7 +220,7 @@ module Samagotchi
       return usage_error("at most #{MAX_IMAGES} images") if options[:images].size > MAX_IMAGES
       return new_options(options) if options[:new]
 
-      %i[dir model].each { |key| return usage_error("--#{key} needs --new") if options[key] }
+      %i[dir model continues].each { |key| return usage_error("--#{key} needs --new") if options[key] }
       LLM_CONTEXT_FLAGS.each { |key, flag| return usage_error("#{flag} needs --new") if options[key] }
       return usage_error("give session ids") if options[:ids].empty?
 
@@ -220,6 +235,15 @@ module Samagotchi
     def new_options(options)
       return usage_error("--new takes no session ids: it starts one session") unless options[:ids].empty?
 
+      if options[:continues]
+        taken = [("--dir" if options[:dir]), ("--model" if options[:model])] +
+                LLM_CONTEXT_FLAGS.filter_map { |key, flag| flag if options[key] }
+        unless taken.compact.empty?
+          return usage_error("--continues takes the previous session's folder, model and LLM context; " \
+                             "leave out #{taken.compact.join(", ")}")
+        end
+      end
+
       words = LLM_CONTEXT_FIELDS.filter_map { |key, field| [field, options[key]] if options[key] }.to_h
       begin
         options[:llm_context] = LLMContextOverride.update(nil, words) unless words.empty?
@@ -253,7 +277,10 @@ module Samagotchi
     # @return [Integer] the exit status
     def run_new(prompt, options)
       images = !@images.empty?
-      if images && (refusal = vision_refusal(options[:model]))
+      model, typed = continued_model(options)
+      return 1 if model == false
+
+      if images && (refusal = vision_refusal(model, typed: typed))
         error_line("chi send: refused: #{refusal}")
         return 1
       end
@@ -264,9 +291,16 @@ module Samagotchi
       through_worker = images || command_like?(prompt)
       begin
         start = through_worker ? { prompt: nil, title: prompt } : { prompt: prompt }
-        session = SessionManager.spawn_session(**start, working_directory: options[:dir],
-                                                        model_name: options[:model], llm_context: options[:llm_context],
-                                                        state_dir: @state_dir)
+        session = if options[:continues]
+                    SessionManager.continue_session(options[:continues], **start, state_dir: @state_dir)
+                  else
+                    SessionManager.spawn_session(**start, working_directory: options[:dir],
+                                                          model_name: options[:model], llm_context: options[:llm_context],
+                                                          state_dir: @state_dir)
+                  end
+      rescue SessionManager::ContinueRefused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
+        error_line("chi send: refused: #{e.message}")
+        return 1
       rescue StandardError => e
         error_line("chi send: could not start a session: #{e.message}")
         return 1
@@ -275,7 +309,7 @@ module Samagotchi
       if through_worker
         return 1 unless deliver_new(session, prompt)
       else
-        @info.puts("#{session.id}  started")
+        @info.puts("#{session.id}  started#{continued_words(session)}")
       end
       @session_id = session.id
       return 0 unless options[:wait]
@@ -285,6 +319,22 @@ module Samagotchi
                                  timeout: options[:timeout])
     end
 
+    # --continues: the model the new link will run (the previous link's),
+    # for the images check; [nil, nil] without --continues.
+    # @return [Array, false] [model_name, model_typed], or false after the
+    #   error line (no such session)
+    def continued_model(options)
+      return [options[:model], nil] unless options[:continues]
+
+      previous = Session.load(SessionChain.resolve(options[:continues], state_dir: @state_dir), state_dir: @state_dir)
+      [previous.model_name, previous.model_typed]
+    rescue ArgumentError => e
+      error_line("chi send: #{e.message}")
+      false
+    end
+
+    def continued_words(session) = session.continues ? " (continues #{session.continues[0, 8]})" : ""
+
     # One existing session, then its next reply. The cursor and baseline
     # are taken before the message goes in, so neither an older reply nor a
     # turn that ends before the first look is mistaken for the answer. A
@@ -371,7 +421,7 @@ module Samagotchi
       end
 
       @sent_command = command_ack?(result[:ack])
-      @info.puts("#{session.id}  started#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
+      @info.puts("#{session.id}  started#{continued_words(session)}#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true
     end
 

data/lib/samagotchi/served_model.rb

@@ -17,6 +17,15 @@ module Samagotchi
       name.is_a?(String) && !name.strip.empty? ? name : nil
     end
 
+    # The host whose hosts.<name>.models.<id>.served names +served+ for
+    # +target+'s model (a gateway's round-robin targets): not a mismatch to
+    # warn about. nil when none does.
+    # @param target [HostRegistry::ModelTarget]
+    # @return [String, nil]
+    def expected_by(target, served)
+      target.entry.name if target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.serves?(served)
+    end
+
     # The separators a provider uses when it decorates a model name: a tag
     # (`qwen3:latest`), a date or quant suffix (`gpt-4o-2024-08-06`), an
     # owner (`@org/name`) or a path (`meta-llama/Llama-3`). Anything else

data/lib/samagotchi/session.rb

@@ -72,6 +72,11 @@ module Samagotchi
     # Started by the `delegate` tool (a fork has a parent_id too, but isn't
     # one): see #delegate?.
     attr_writer :delegate
+    # The session this one continues (SessionManager.continue_session): the
+    # previous link of a chain, "the next day of the same routine", else
+    # nil. Not a parent: archiving one link leaves the next alone. The chain
+    # itself is derived (SessionChain), never stored.
+    attr_accessor :continues
     # A `chi scratch` session: deleted when its REPL ends, and by the next
     # sweep (or `chi sessions clean`) when the process died first.
     attr_accessor :scratch
@@ -130,7 +135,8 @@ module Samagotchi
                    first_preview: "", test_run: false, pending_question: nil,
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
-                   last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [])
+                   last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
+                   continues: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -154,6 +160,7 @@ module Samagotchi
       @scratch = !!scratch
       @last_turn = last_turn
       @delegate = !!delegate
+      @continues = continues&.to_s
       self.llm_context = llm_context
       @archived = false
     end
@@ -205,7 +212,7 @@ module Samagotchi
     #   seed); [] by default
     def self.new_session(mode:, model_name:, working_directory:, test_run: nil,
                          preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, messages: [],
-                         scratch: false, model_typed: nil, delegate: false, llm_context: nil)
+                         scratch: false, model_typed: nil, delegate: false, llm_context: nil, continues: nil)
       now = Time.now.iso8601(3)
       resolved_test = if test_run.nil?
                         test_session_env?
@@ -230,7 +237,8 @@ module Samagotchi
         parent_id: parent_id,
         scratch: scratch,
         delegate: delegate,
-        llm_context: llm_context
+        llm_context: llm_context,
+        continues: continues
       )
     end
 
@@ -287,7 +295,8 @@ module Samagotchi
       "scratch" => false,
       "last_turn" => nil,
       "delegate" => false,
-      "llm_context" => nil
+      "llm_context" => nil,
+      "continues" => nil
     }.freeze
 
     # A session from a parsed session file. +messages+ false leaves the