samagotchi 0.63.0 → 0.65.0

data/lib/samagotchi/llm/model_result.rb

@@ -15,17 +15,24 @@ module Samagotchi
     # conversation) and .empty_retries (the retries spent): the Engine saves
     # them on the turn's note for the UIs (TurnNote.empty).
     #
+    # .refusal is set when the provider refused the answer (Messages'
+    # stop_reason refusal, OpenAI's content_filter): {category:} as the
+    # provider names it, {} without one; nil otherwise. Such a turn is an
+    # empty answer the loop never asked again.
+    #
     # .run_start is where the turn's run started in the conversation (the
     # length of the messages the loop got), set by the Engine after the loop
     # returns; nil from a loop called directly. A step-limit offer keeps it
     # (TurnFlow), so a Continue resumes that run (Engine#run_turn resume_from:).
     class ModelResult
       attr_reader :text, :conversation, :canceled, :cancellation_reason, :exhausted,
-                  :tool_activity, :context_status, :pending_tool_calls, :empty_steps, :empty_retries
+                  :tool_activity, :context_status, :pending_tool_calls, :empty_steps, :empty_retries, :refusal
       attr_accessor :run_start
 
       def initialize(text:, conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
-                     tool_activity: [], context_status: nil, pending_tool_calls: false, empty_steps: [], empty_retries: 0)
+                     tool_activity: [], context_status: nil, pending_tool_calls: false, empty_steps: [], empty_retries: 0,
+                     refusal: nil)
+        @refusal = refusal
         @empty_steps = Array(empty_steps)
         @empty_retries = empty_retries.to_i
         @text = text

data/lib/samagotchi/llm/openai_chat.rb

@@ -4,30 +4,16 @@ require "json"
 require "uri"
 require_relative "../config"
 require_relative "../sampling_settings"
+require_relative "../thinking"
 require_relative "errors"
 require_relative "http"
+require_relative "model_listing"
 require_relative "prompt_cache"
 require_relative "usage"
 require_relative "utf8_scrub"
 
 module Samagotchi
   module LLM
-    # A model a host lists. Unknown fields are nil.
-    ModelInfo = Data.define(:id, :context_window, :supports_tools, :raw) do
-      # true when the list says the model takes images (OpenRouter's
-      # architecture.input_modalities, llama.cpp's "multimodal" capability),
-      # false when it lists input modalities without "image", else nil.
-      def image_input
-        return nil unless raw.is_a?(Hash)
-
-        modalities = raw.dig("architecture", "input_modalities")
-        return modalities.include?("image") if modalities.is_a?(Array)
-        return true if Array(raw["capabilities"]).include?("multimodal")
-
-        nil
-      end
-    end
-
     # A tool call the model made. arguments: the parsed Hash, or the raw
     # String when it isn't valid JSON (the tool then reports the error).
     ToolCall = Data.define(:id, :name, :arguments)
@@ -43,9 +29,17 @@ module Samagotchi
     # +top_logprobs+: the first answer token's likeliest alternatives
     # (TokenLogprob) when the request asked for logprobs and the server
     # sent them (a non-streamed answer only); [] otherwise.
+    # +provider_content+: the response's content blocks in order, as the
+    # server sent them (string keys), for a wire that sends them back
+    # verbatim (AnthropicMessages: thinking blocks with their signatures);
+    # nil on the OpenAI wire.
+    # +stop_details+: why the provider stopped, when it says more than the
+    # finish reason (Messages' stop_details on a refusal: type, category,
+    # explanation; string keys); nil otherwise.
     ChatResponse = Data.define(:text, :reasoning, :tool_calls, :usage, :finish_reason, :model, :provider, :cut,
-                               :top_logprobs) do
-      def initialize(model: nil, provider: nil, cut: nil, top_logprobs: [].freeze, **fields) = super
+                               :top_logprobs, :provider_content, :stop_details) do
+      def initialize(model: nil, provider: nil, cut: nil, top_logprobs: [].freeze, provider_content: nil, stop_details: nil,
+                     **fields) = super
     end
 
     # One alternative for an answer token: its text and log probability.
@@ -75,6 +69,8 @@ module Samagotchi
     # default, with errors mapped to ProviderError. It speaks the wire format
     # only; the chat loop owns the conversation and the tools.
     class OpenAIChat
+      include ModelListing
+
       MAX_MODEL_PAGES = 20
       # How much of a 200's non-stream body is read as a possible JSON error.
       PLAIN_ERROR_LIMIT = 64 * 1024
@@ -90,14 +86,11 @@ module Samagotchi
 
       # @param entry [HostRegistry::HostEntry]
       def self.for(entry, **)
-        new(base_url: entry.openai_base_url, host_name: entry.name, api_key_env: entry.api_key_env,
-            remote: entry.remote?, default_max_tokens: (OPENROUTER_MAX_TOKENS if openrouter?(entry.openai_base_url)),
+        new(base_url: entry.api_base_url, host_name: entry.name, api_key_env: entry.api_key_env, auth: entry.auth,
+            remote: entry.remote?, default_max_tokens: (OPENROUTER_MAX_TOKENS if openrouter?(entry.api_base_url)),
             **)
       end
 
-      # true when a streamed +payload+ carries a tool-call delta.
-      def self.tool_call_delta?(payload) = Assembly.tool_call_delta?(payload)
-
       # true when +url+ is OpenRouter's API (openrouter.ai or a subdomain).
       def self.openrouter?(url)
         host = URI(url.to_s).host.to_s.downcase
@@ -134,19 +127,23 @@ module Samagotchi
       # @param host_name [String] names the host in errors
       # @param api_key_env [String, nil] the variable holding the API key;
       #   nil sends no Authorization header (a local server)
+      # @param auth [Symbol, nil] the header the key goes in
+      #   (ApiKey::SCHEMES); nil: Authorization: Bearer
       # @param stream [Boolean] stream the reply (false: one JSON body)
       # @param retries [Boolean] false: one attempt
       # @param timeout [Numeric, nil] read timeout in seconds (default
       #   server.read_timeout); the connect timeout is capped by it
+      # @param open_timeout [Numeric, nil] connect timeout in seconds, when
+      #   shorter than that (a reachability probe's)
       # @param models_ttl [Numeric] how long #context_window reuses the list
       # @param remote [Boolean] a provider on the network, not a local server
       # @param first_token_timeout [Numeric, nil] seconds a streamed answer
       #   may take to show something (LLM::HTTP); nil: no limit
       # @param default_max_tokens [Integer, nil] max_tokens for a request
       #   whose options name none (OPENROUTER_MAX_TOKENS); nil sends none
-      def initialize(base_url:, host_name:, api_key_env: nil, stream: true, retries: true, timeout: nil,
+      def initialize(base_url:, host_name:, api_key_env: nil, auth: nil, stream: true, retries: true, timeout: nil,
                      env: ENV, sleeper: nil, retry_policy: nil, models_ttl: DEFAULT_MODELS_TTL, remote: false,
-                     first_token_timeout: nil, purpose: "chat", default_max_tokens: nil)
+                     first_token_timeout: nil, purpose: "chat", default_max_tokens: nil, open_timeout: nil)
         @remote = remote
         @default_max_tokens = default_max_tokens
         # What its requests are for, in the log (LLM::HTTP::LOGGED_PURPOSES).
@@ -156,13 +153,12 @@ module Samagotchi
         @host_name = host_name.to_s
         @api_key_env = api_key_env
         @stream = stream
-        @models_ttl = models_ttl
-        @models_mutex = Mutex.new
-        open_timeout, read_timeout = timeouts(timeout)
+        init_model_listing(models_ttl)
+        open_timeout, read_timeout = timeouts(timeout, open_timeout)
         policy = retry_policy || (retries ? nil : HTTP::RetryPolicy.none)
         @http = HTTP.new(label: @host_name, open_timeout: open_timeout, read_timeout: read_timeout,
                          retry_policy: policy, sleeper: sleeper, first_token_timeout: first_token_timeout,
-                         api_key: ApiKey.for(api_key_env, host: @host_name, env: env))
+                         api_key: ApiKey.for(api_key_env, host: @host_name, env: env, scheme: auth))
       end
 
       # @param messages [Array<Hash>] wire messages (role, content, tool_calls,
@@ -216,6 +212,25 @@ module Samagotchi
       # A provider on the network: no llama.cpp /props to ask for the window.
       def remote? = @remote
 
+      # Model entries go back as text, tool_calls and reasoning_content,
+      # never as saved provider blocks (AnthropicMessages does).
+      def replays_content? = false
+
+      # true when a streamed chunk's +payload+ (as #chat's on_delta gets it)
+      # carries part of a tool call (ChatLoop marks the chunk's event).
+      def tool_call_delta?(payload) = Assembly.tool_call_delta?(payload)
+
+      # The request fields a thinking +level+ (Thinking::LEVELS) adds on
+      # this wire: Thinking.chat_fields's OpenAI-style switches.
+      # @return [Hash] frozen
+      def thinking_fields(level) = Thinking.chat_fields(level)
+
+      # The thinking fields for a short side answer from a model that
+      # refused thinking off (gpt-oss: "Reasoning is mandatory"): none, the
+      # model's own default.
+      # @return [Hash] frozen
+      def thinking_off_refused_fields = {}.freeze
+
       # @return [Array<ModelInfo>] the host's models (every page)
       def list_models
         models = []
@@ -231,26 +246,6 @@ module Samagotchi
         models
       end
 
-      # The window (tokens) the host lists for +model+, or nil. The list is
-      # read once per models_ttl; a failed listing answers nil.
-      def context_window(model:)
-        info = cached_models.find { |m| m.id == model.to_s } ||
-               cached_models.find { |m| m.id.casecmp?(model.to_s) }
-        info&.context_window
-      rescue StandardError
-        nil
-      end
-
-      # Whether the host's list says +model+ takes images (ModelInfo#image_input),
-      # or nil when it doesn't say or the listing fails.
-      def image_input(model:)
-        info = cached_models.find { |m| m.id == model.to_s } ||
-               cached_models.find { |m| m.id.casecmp?(model.to_s) }
-        info&.image_input
-      rescue StandardError
-        nil
-      end
-
       def self.served_model(payload)
         model = payload.is_a?(Hash) ? payload["model"] : nil
         model.is_a?(String) && !model.strip.empty? ? model : nil
@@ -265,9 +260,10 @@ module Samagotchi
 
       private
 
-      def timeouts(timeout)
+      def timeouts(timeout, open_limit = nil)
         open_timeout = Samagotchi::Config.positive_seconds("server.open_timeout")
         read_timeout = Samagotchi::Config.positive_seconds("server.read_timeout")
+        open_timeout = [open_timeout, open_limit].min if open_limit
         return [open_timeout, read_timeout] unless timeout
 
         [[open_timeout, timeout].min, timeout]
@@ -411,49 +407,6 @@ module Samagotchi
 
       def get_request(uri) = Net::HTTP::Get.new(uri)
 
-      def model_entries(body)
-        return [] unless body.is_a?(Hash)
-
-        entries = body["data"].is_a?(Array) ? body["data"] : body["models"]
-        Array(entries).select { |entry| entry.is_a?(Hash) }
-      end
-
-      def model_info(raw)
-        id = (raw["id"] || raw["model"] || raw["name"]).to_s
-        ModelInfo.new(id: id, context_window: window_of(raw), supports_tools: tools_support(raw), raw: raw)
-      end
-
-      # The running window when the list says: context_length, context_window,
-      # max_model_len, or llama.cpp's meta.n_ctx (not n_ctx_train).
-      def window_of(raw)
-        [raw["context_length"], raw["context_window"], raw["max_model_len"], raw.dig("meta", "n_ctx")].each do |value|
-          return value if value.is_a?(Integer) && value.positive?
-        end
-        nil
-      end
-
-      def tools_support(raw)
-        listed = raw["supported_parameters"] || raw["capabilities"]
-        return nil unless listed.is_a?(Array)
-
-        listed.include?("tools") || nil
-      end
-
-      def cached_models
-        @models_mutex.synchronize do
-          fresh = @models_at && (monotonic - @models_at) < @models_ttl
-          return @models if fresh
-        end
-        models = list_models
-        @models_mutex.synchronize do
-          @models = models
-          @models_at = monotonic
-        end
-        models
-      end
-
-      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
       # Streamed deltas put together: text, reasoning, tool calls by index,
       # the finish reason, the usage chunk, the served model and provider.
       class Assembly

data/lib/samagotchi/model_profile.rb

@@ -484,7 +484,7 @@ module Samagotchi
     private_class_method :configured
 
     # Only a native llama.cpp host has /props with a chat template; a chat
-    # host (api: openai) barely uses a profile, and mlx/oMLX expose none.
+    # host (api: openai or anthropic) barely uses a profile, and mlx/oMLX expose none.
     def self.probe?(entry, client)
       return false if client.nil? || !client.respond_to?(:server_props)
       return false if entry&.chat?

data/lib/samagotchi/pending_input_queue.rb

@@ -19,17 +19,24 @@ module Samagotchi
     end
 
     # Append a message to the queue. Nil/empty strings are ignored.
-    def push(text)
+    # +seq+ is the sender's own order number for it (the REPL numbers every
+    # line it takes during a turn, so its leftovers keep send order across
+    # this queue and its after-turn list: #drain_entries).
+    def push(text, seq: nil)
       text = text.to_s
       return if text.empty?
 
-      @mutex.synchronize { @messages << text }
+      @mutex.synchronize { @messages << [seq, text] }
       nil
     end
 
     # Remove and return all queued messages in FIFO order. Non-blocking.
     # @return [Array<String>]
-    def drain
+    def drain = drain_entries.map(&:last)
+
+    # #drain with each message's +seq+ (nil when pushed without one).
+    # @return [Array(Integer|nil, String)]
+    def drain_entries
       @mutex.synchronize do
         drained = @messages
         @messages = []

data/lib/samagotchi/plugin/sessions.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../client_id"
+require_relative "../delivery"
 require_relative "../session"
 require_relative "../bridge_client"
 require_relative "../bridge/turn_accumulator"
@@ -62,18 +63,28 @@ module Samagotchi
       # Send +text+ to session +id+ as a user message (it runs as a turn;
       # a stopped session is woken). Waits up to 5 s for its worker, so call
       # it from an anytime command or your own thread, never a tool or hook
-      # of a running turn.
+      # of a running turn. A running turn takes it at its next step; with
+      # +delivery: :queue+ it runs as a turn of its own after that one
+      # instead. A plugin never cuts the running turn's thinking.
+      # @param delivery [Symbol, String, nil] nil or :next_step (default),
+      #   :queue
       # @return [String] the id of the session it went to
-      # @raise [Error] no such session, a REPL owns it, or it wasn't taken
-      def send(id, text)
+      # @raise [Error] no such session, a REPL owns it, it wasn't taken
+      #   (a worker older than queueing refuses a queue), or delivery is
+      #   :cut or unknown
+      def send(id, text, delivery: nil)
         raise Error, "nothing to send" if text.to_s.strip.empty?
 
+        wire = plugin_delivery(delivery)
         state_dir = self.state_dir
         sid = resolve(id, state_dir)
-        delivered = SessionManager.deliver_turn(sid, prompt: text.to_s, client_id: ClientId::PLUGIN, state_dir: state_dir)
+        delivered = SessionManager.deliver_turn(sid, prompt: text.to_s, client_id: ClientId::PLUGIN, state_dir: state_dir,
+                                                     delivery: wire)
         case delivered[:status]
         when :accepted then sid
-        when :refused then raise Error, "session #{sid[0, 8]} refused the message (#{delivered.dig(:ack, "error")})"
+        when :refused
+          ack = delivered[:ack] || {}
+          raise Error, "session #{sid[0, 8]} refused the message (#{ack["error"]}#{": #{ack["detail"]}" if ack["detail"]})"
         when :timeout then raise Error, "session #{sid[0, 8]}'s worker did not answer in time; the message was not sent"
         else raise Error, "the message to session #{sid[0, 8]} could not be written"
         end
@@ -81,6 +92,17 @@ module Samagotchi
         raise Error, "session #{sid[0, 8]} is open in a chi REPL, which takes no messages from others"
       end
 
+      # The wire value for send's delivery: (nil for the default).
+      def plugin_delivery(delivery)
+        case delivery&.to_s
+        when nil, "", Delivery::NEXT_STEP then nil
+        when Delivery::QUEUE then Delivery::QUEUE
+        when Delivery::CUT then raise Error, "plugins never cut: send it plain (the next step) or delivery: :queue"
+        else raise Error, "delivery takes :next_step or :queue, not #{delivery.inspect}"
+        end
+      end
+      private :plugin_delivery
+
       # Session +id+ now: from its worker when one runs (with a running turn
       # so far), else as saved.
       # @return [Hash] {id:, title:, status:, parent_id:, running:, messages:}

data/lib/samagotchi/reasoning_history.rb

@@ -16,12 +16,17 @@ module Samagotchi
   #
   # Order (#resolve): the session's own level (/reasoning-history), then
   # SAMAGOTCHI_REASONING_HISTORY, models.<key>.reasoning_history,
-  # hosts.<name>.reasoning_history, then turn. Native hosts ignore it:
+  # hosts.<name>.reasoning_history, then the host's api default: all for
+  # api: anthropic (its thinking blocks go back verbatim, and removing
+  # earlier turns' would rewrite the cached prefix every turn; ChatLoop
+  # floors drop at turn there), turn elsewhere. Native hosts ignore it:
   # KernelLoop keeps the running turn's reasoning on its own, from the
   # run's start (.run_start).
   module ReasoningHistory
     LEVELS = %i[drop turn all].freeze
     DEFAULT = :turn
+    # The default for a host's api when it isn't DEFAULT.
+    API_DEFAULTS = { anthropic: :all }.freeze
     KEY = "reasoning_history"
     ENV_NAME = "SAMAGOTCHI_REASONING_HISTORY"
     # The source a session's own level reads as.
@@ -82,7 +87,7 @@ module Samagotchi
       host = target.entry&.reasoning_history
       return [host, "hosts.#{target.entry.name}"] if host
 
-      [DEFAULT, nil]
+      [API_DEFAULTS.fetch(target.entry&.api&.to_sym, DEFAULT), nil]
     end
 
     # #resolve, as a SettingExplained with the session's own level beside it.
@@ -112,10 +117,15 @@ module Samagotchi
     end
 
     # Whether +conversation+ has a model entry with thinking (what all
-    # sends back as reasoning_content; LLM::ChatLoop#thought?).
+    # sends back as reasoning_content; LLM::ChatLoop#thought?), or with a
+    # saved thinking block (a Messages host's, which may carry no text:
+    # Claude's omitted display).
     def earlier_thought?(conversation)
       Array(conversation).any? do |entry|
-        entry[:role].to_s == "model" && entry[:thinking].is_a?(String) && !entry[:thinking].strip.empty?
+        next false unless entry[:role].to_s == "model"
+
+        (entry[:thinking].is_a?(String) && !entry[:thinking].strip.empty?) ||
+          Array(entry[:anthropic_content]).any? { |block| block.is_a?(Hash) && %w[thinking redacted_thinking].include?(block["type"].to_s) }
       end
     end
 

data/lib/samagotchi/recap_setup.rb

@@ -65,7 +65,8 @@ module Samagotchi
         min_user_turns: recap_number_setting(kwarg_config, :min_user_turns, "recap.min_user_turns", IdleRecap::DEFAULT_MIN_USER_TURNS, :int),
         timeout: recap_number_setting(kwarg_config, :timeout, "recap.timeout", IdleRecap::DEFAULT_TIMEOUT_SECONDS, :float),
         sentences: recap_sentences(string_config(kwarg_config, :sentences) || registry_string("recap.sentences")),
-        store: RecapStore.new(session_id_lookup: -> { session_id.call }, state_dir_lookup: -> { state_dir.call })
+        store: RecapStore.new(session_id_lookup: -> { session_id.call }, state_dir_lookup: -> { state_dir.call }),
+        session_id: -> { session_id.call }
       )
     end
 

data/lib/samagotchi/reply_wait.rb

@@ -3,6 +3,7 @@
 require_relative "session"
 require_relative "turn_note"
 require_relative "session_inbox"
+require_relative "worker_sidecar"
 
 module Samagotchi
   # Loaded on first use: session_manager requires terminal_ui, which
@@ -14,9 +15,15 @@ module Samagotchi
   # output/<timestamp>.txt file (one per turn that ended with visible text,
   # written just before its idle save), so "next" means a filename past the
   # cursor the caller holds: the newest one it already has, or nil for any.
+  # A wait for one input's turn (turn:, a queued message) looks for that
+  # turn's own file instead (output/<timestamp>-<enqueued_id>.txt).
   # The delegate tools and `chi send --wait` wrap it in their own words.
   module ReplyWait
     POLL_INTERVAL = 0.5
+    # A worker's sidecar feature (Bridge::FEATURES): its running turn's
+    # checkpoint mark (InterruptedTurn#enqueued_id), a continue turn and a
+    # Stop's last_turn carry the turn's enqueued_id (#own_turn).
+    TURN_IDS_FEATURE = "turn_ids"
 
     # @!attribute status [Symbol] :done, :waiting_for_answer, :no_reply,
     #   :error, :stopped, :canceled, :timeout or :worker_gone
@@ -38,7 +45,9 @@ module Samagotchi
     # @!attribute retryable [Boolean, nil] whether that error may pass on a
     #   retry
     # @!attribute cancel_reason [String, nil] a "canceled" turn's reason
-    #   (user, hook, ctrl_c, manual)
+    #   (user, hook, ctrl_c, manual, session_stopped: the session was
+    #   stopped mid-turn), passed through as the worker saved it; any
+    #   reason is a "canceled" outcome
     # @!attribute stopped_by [String, nil] the hook that canceled it
     #   (loop-guard)
     # @!attribute session [Session, nil] the session as the look that
@@ -70,18 +79,64 @@ module Samagotchi
     # @param interject [#call, nil] called once a poll, before the sleep
     #   (the delegate wait relays other children's approvals there); the
     #   time it takes doesn't count against +timeout+
+    # @param turn [String, nil] the enqueued_id of the input whose turn is
+    #   waited for (a queued message, which runs after the turn running
+    #   now). With it only that turn ends the wait: its reply file
+    #   (SessionInbox.reply_for), or an idle session whose last_turn has
+    #   that enqueued_id (failed, canceled, empty: #no_reply). Other turns'
+    #   replies and ends are not its, and a pending question counts only
+    #   when it is that turn's (#own_question?). A last_turn that ended
+    #   before the baseline's (the turn whose continue offer was just
+    #   answered) is not the end. An input a running turn merged as a
+    #   steer (taken, never run as its own) is waited for as without turn:
+    #   (that turn's reply or question). A turn seen running, then past
+    #   (another turn runs or ended, last_turn not it): :no_reply, outcome
+    #   unknown.
+    # @param queued [Boolean] the turn: input was sent as a queue (or with
+    #   images), which a running turn never merges: no fallback, even when
+    #   its file was taken before the first look
     # @return [Result]
     # @raise [ArgumentError] no such session
     def call(id, state_dir:, cursor:, timeout: nil, poll_interval: POLL_INTERVAL, cancelled: -> { false },
-             baseline: nil, owner_grace: nil, interject: nil)
+             baseline: nil, owner_grace: nil, interject: nil, turn: nil, queued: false)
       deadline = timeout && (monotonic + timeout.to_f)
       seen_running = false
       gone_since = nil
+      turn = turn.to_s.empty? ? nil : turn.to_s
+      session_dir = Session.session_dir(id, state_dir: state_dir) if turn
+      # Whether the turn's input file has been taken (latched): looked at
+      # before each load, so a running session seen after it is that turn
+      # or a later one, never the turn that ran when the message was sent.
+      claimed = false
+      # Its input runs a turn of its own (a queue, images: +queued+, or seen
+      # waiting as one): never merged into another turn.
+      own_turn_input = queued
+      # The turn was seen running (its mark's id), and last_turn's ended_at
+      # then: a later end that isn't its is a turn after it.
+      seen_own = false
+      own_base = nil
 
       loop do
+        if turn && !claimed
+          waiting = SessionInbox.waiting_input(session_dir, turn)
+          own_turn_input ||= waiting == :turn_end
+          claimed = waiting.nil?
+        end
         session = Session.load(id, state_dir: state_dir)
+        if turn && !seen_own && session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == turn
+          seen_own = true
+          own_base = session.last_turn&.ended_at
+        end
+        # Taken but never run as a turn of its own: a running turn's drain
+        # merged it as a steer, so that turn's reply (or question) is its
+        # answer. Waited for as the next reply past the cursor, as without
+        # turn:, never as a turn that will not come.
+        if turn && claimed && !seen_own && !own_turn_input && merged_elsewhere?(session, turn, baseline, session_dir)
+          turn = nil
+          seen_running = session.status == Session::STATUS_RUNNING
+        end
 
-        if (reply = reply_past(id, state_dir: state_dir, cursor: cursor))
+        if (reply = turn ? reply_for_turn(id, state_dir: state_dir, turn: turn) : reply_past(id, state_dir: state_dir, cursor: cursor))
           reply.session = settled(session, id, state_dir: state_dir)
           return reply
         end
@@ -98,13 +153,31 @@ module Samagotchi
         # REPL's is answered there.
         pending = session.pending_question
         if pending && !(baseline && pending[:id] == baseline[:question_id]) &&
+           (turn.nil? || own_question?(session, turn, claimed)) &&
            session.waiting_question(live: SessionManager.worker_live?(id, state_dir: state_dir))
           return Result.new(status: :waiting_for_answer, question: pending, session: session)
         end
 
         return Result.new(status: :canceled) if cancelled.call
 
-        if session.status == Session::STATUS_RUNNING
+        if turn
+          # Only the turn's own end: the session runs another turn when the
+          # wait starts, and that one's end is not the answer. A last_turn
+          # with its id is its end, even with a next queued turn running
+          # by now (the look between the two missed the idle).
+          # Only an end after the baseline: a continue offer answered from
+          # idle leaves the exhausted turn's last_turn, with the same id,
+          # until the continue turn (or a Stop) records its own.
+          if session.last_turn&.enqueued_id == turn && ended_since_baseline?(session, baseline)
+            return reply_for_turn(id, state_dir: state_dir, turn: turn)&.tap { |r| r.session = session } ||
+                   no_reply(session, baseline, fresh: true)
+          end
+          # Seen running, and now another turn runs or a later turn ended
+          # while last_turn (looked at first) isn't its: lost (its worker
+          # died), or it ended with no reply and a next turn ran and ended
+          # between two looks. Waiting on would sit through those turns.
+          return Result.new(status: :no_reply, session: session) if seen_own && past_own?(session, turn, own_base)
+        elsif session.status == Session::STATUS_RUNNING
           seen_running = true
         elsif (seen_running && !baseline&.key?(:last_turn)) || turn_ended_since?(session, baseline)
           # It ran and is idle again with no new reply: canceled, failed or
@@ -164,11 +237,103 @@ module Samagotchi
       !!(baseline[:messages] && session.messages.size > baseline[:messages])
     end
 
+    # The turn a caller that sent nothing means (chi answer, chi send --wait
+    # with no message): the one running now (its checkpoint mark's
+    # enqueued_id), or, idle, the turn whose continue offer stands (its
+    # last_turn's), when the worker's sidecar says it ties a continue turn
+    # to that id (TURN_IDS_FEATURE). nil otherwise (no id known, a worker
+    # from before): the caller waits for the next reply as before.
+    # @param session [Session] the session as loaded now
+    # @return [String, nil] an enqueued_id for call's turn:
+    def own_turn(session, session_dir:)
+      if session.status == Session::STATUS_RUNNING
+        # Only a worker that writes it has one: no feature check.
+        return session.interrupted_turn&.enqueued_id
+      end
+
+      pending = session.pending_question
+      return nil unless pending && pending[:kind].to_s == "continue"
+      return nil unless turn_ids?(session_dir)
+
+      session.last_turn&.enqueued_id
+    end
+
+    # Whether the session's worker sidecar names TURN_IDS_FEATURE.
+    def turn_ids?(session_dir)
+      WorkerSidecar.read(session_dir)&.features&.include?(TURN_IDS_FEATURE) || false
+    end
+
+    # A pending question is a turn: wait's (its enqueued_id) only when that
+    # turn asked it. While a turn runs its checkpoint mark says which turn
+    # that is (a continue turn carries its offer turn's id); a mark with no
+    # id (a worker from before) falls back to the claimed rule (its input
+    # claimed, the session running, last_turn not already it). Idle: only
+    # its own continue offer (last_turn has the id). Any other is another
+    # turn's, whose questions are the user's: the wait goes on.
+    def own_question?(session, turn, claimed)
+      ended = session.last_turn&.enqueued_id == turn
+      return ended unless session.status == Session::STATUS_RUNNING
+
+      running_id = session.interrupted_turn&.enqueued_id
+      return running_id == turn if running_id
+
+      # Ended, running again: a next turn.
+      !ended && claimed
+    end
+
+    # The turn's end, after the baseline was taken (with no baseline, or
+    # one without last_turn, any).
+    def ended_since_baseline?(session, baseline)
+      return true unless baseline&.key?(:last_turn)
+
+      session.last_turn&.ended_at != baseline[:last_turn]
+    end
+
+    # A turn: wait's taken input ran in another turn (a steer its drain
+    # merged): that turn runs (its mark has another id, or none from a
+    # worker that writes ids), or, idle, a turn not its ended since the
+    # baseline. last_turn or a reply file being its own is never that.
+    def merged_elsewhere?(session, turn, baseline, session_dir)
+      return false if session.last_turn&.enqueued_id == turn || SessionInbox.reply_for(session_dir, turn)
+
+      if session.status == Session::STATUS_RUNNING
+        running_id = session.interrupted_turn&.enqueued_id
+        return running_id != turn if running_id
+
+        return turn_ids?(session_dir)
+      end
+      baseline&.key?(:last_turn) ? turn_ended_since?(session, baseline) : false
+    end
+
+    # A turn seen running (+own_base+: last_turn's ended_at then) is past:
+    # last_turn isn't its, and another turn runs (a mark with another id)
+    # or a turn ended since.
+    def past_own?(session, turn, own_base)
+      return false if session.last_turn&.enqueued_id == turn
+
+      running_id = session.status == Session::STATUS_RUNNING ? session.interrupted_turn&.enqueued_id : nil
+      return true if running_id && running_id != turn
+
+      ended = session.last_turn&.ended_at
+      !ended.nil? && ended != own_base
+    end
+
+    # @return [Result, nil] :done with the reply of the turn that ran the
+    #   input +turn+ (its enqueued_id)
+    def reply_for_turn(id, state_dir:, turn:)
+      file = SessionInbox.reply_for(Session.session_dir(id, state_dir: state_dir), turn)
+      return nil unless file
+
+      Result.new(status: :done, text: File.read(File.join(reply_dir(id, state_dir: state_dir), file)), file: file)
+    end
+
+    # @param fresh [Boolean, nil] the last_turn is known to be the turn
+    #   waited for (a turn: wait); nil decides it from the baseline
     # @return [Result] :no_reply with the outcome the session's last_turn
     #   records, when it is the turn waited for
-    def no_reply(session, baseline)
+    def no_reply(session, baseline, fresh: nil)
       last = session.last_turn || LastTurn.new
-      fresh = baseline.nil? || !baseline.key?(:last_turn) || (last.ended_at && last.ended_at != baseline[:last_turn])
+      fresh = baseline.nil? || !baseline.key?(:last_turn) || (last.ended_at && last.ended_at != baseline[:last_turn]) if fresh.nil?
       outcome = fresh ? last.outcome : nil
       return Result.new(status: :no_reply, outcome: "exhausted", limit: last.limit, session: session) if fresh && last.exhausted