samagotchi 0.109.0 → 0.111.0

data/lib/samagotchi/message_time.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Samagotchi
+  # When a history entry happened: its wall-clock stamp (KEY), and the
+  # dividers the UIs print when a quiet gap passes between two entries.
+  #
+  # The stamp is display-only: no wire format reads it, so the bytes the
+  # model gets (and its prompt cache) are the same with or without it. A
+  # time the model should read is baked into the message's content when the
+  # message is made (ReminderQueue's header), never rendered at wire time.
+  #
+  # Everything here is a pure function of the times passed in; the one wall
+  # clock is #now (a seam the specs pin to a fixed time).
+  module MessageTime
+    # The history entry key: a local-offset ISO 8601 time with milliseconds.
+    KEY = :at
+    # The quiet time after which the UIs mark a gap.
+    GAP_SECONDS = 600
+
+    DEFAULT_SOURCE = -> { Time.now }
+    private_constant :DEFAULT_SOURCE
+
+    class << self
+      # The wall clock: a callable returning a Time (nil: Time.now).
+      attr_writer :source
+
+      # @return [Time] now, by the wall clock seam
+      def now = (@source || DEFAULT_SOURCE).call
+
+      # Back to Time.now.
+      def reset! = @source = nil
+    end
+
+    module_function
+
+    # @param time [Time]
+    # @return [String] the stamp's text
+    def iso(time) = time.iso8601(3)
+
+    # The stamp of an ISO text from elsewhere (a note's created_at), or nil
+    # when it doesn't parse.
+    def iso_of(text)
+      text && iso(Time.iso8601(text.to_s))
+    rescue ArgumentError
+      nil
+    end
+
+    # +message+ with KEY set to +time+'s stamp, unless it has one already
+    # (a Symbol- or String-keyed message). Changes +message+ and returns it.
+    def stamp(message, time)
+      return message if message.key?(KEY) || message.key?(KEY.to_s)
+
+      message[KEY] = time.is_a?(String) ? time : iso(time)
+      message
+    end
+
+    # @return [String, nil] the stamp of +message+ (Symbol or String keys)
+    def of(message)
+      return nil unless message.is_a?(Hash)
+
+      message[KEY] || message[KEY.to_s]
+    end
+
+    # @return [String, nil] "14:32", local time
+    def clock(iso) = local(iso)&.strftime("%H:%M")
+
+    # @return [String, nil] "Sat 24 Oct 09:10", local time
+    def day_clock(iso) = local(iso)&.strftime("%a %-d %b %H:%M")
+
+    # The divider between activity that ended at +prev_iso+ and activity
+    # starting at +cur_iso+: nil below GAP_SECONDS (or when either time is
+    # unknown), else "── 14:32 · 47 min later ──", the date added when the
+    # local day changed.
+    def gap_line(prev_iso, cur_iso)
+      prev = local(prev_iso)
+      cur = local(cur_iso)
+      return nil unless prev && cur
+
+      seconds = cur - prev
+      return nil if seconds < GAP_SECONDS
+
+      time = prev.to_date == cur.to_date ? cur.strftime("%H:%M") : cur.strftime("%a %-d %b %H:%M")
+      "── #{time} · #{ago(seconds)} later ──"
+    end
+
+    # @return [String] "47 min", "3 h", "2 d" (whole units, rounded down;
+    #   the web's relativeTime scale)
+    def ago(seconds)
+      seconds = seconds.to_f
+      return "#{[(seconds / 60).floor, 0].max} min" if seconds < 3600
+      return "#{(seconds / 3600).floor} h" if seconds < 86_400
+
+      "#{(seconds / 86_400).floor} d"
+    end
+
+    def local(iso)
+      iso && Time.iso8601(iso.to_s).localtime
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/samagotchi/model_binding.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "effective_model"
+require_relative "model_overlay"
+require_relative "model_profile"
+
+module Samagotchi
+  # An Engine's model choice (ModelChoice: the model as given and as typed)
+  # and the prompt profile resolved for it, under one mutex; the counterpart
+  # of ToolkitBinding. The memory overlay keys follow the choice
+  # (#sync_model_key!).
+  #
+  # The choice changes in one assignment under the mutex (#switch!), so a
+  # reader on another thread sees the old pair or the new one. A resolution
+  # is kept and applied only for the choice it was resolved for, by
+  # identity (#store_profile: a /stats on a Bridge thread probing while
+  # /model runs keeps nothing). Nothing else takes the mutex.
+  #
+  # What it needs from the Engine comes through lookups, called at use; the
+  # Engine forwards each method here.
+  class ModelBinding
+    # @param choice         [ModelChoice] the starting model
+    # @param given_profile  [ModelProfile, nil] a caller's profile (until a switch)
+    # @param registry       [HostRegistry]
+    # @param kernel         [#call] → KernelLoop
+    # @param prompt_builder [#call] → SystemPrompt, nil while the Engine is built
+    # @param bare_name      [#call] (ref) → the model id sent for +ref+
+    def initialize(choice:, given_profile:, registry:, kernel:, prompt_builder:, bare_name:)
+      @choice = choice
+      @given_profile = given_profile
+      @registry = registry
+      @kernel = kernel
+      @prompt_builder = prompt_builder
+      @bare_name = bare_name
+      # Guards the model choice and the profile cached for it (#store_profile).
+      @mutex = Mutex.new
+      # [choice, resolution]: the resolution kept, with the choice it is for.
+      @resolution = nil
+      @model_key = nil
+      @fallback_model_key = nil
+    end
+
+    # @return [ModelChoice] the model turns run on now
+    attr_reader :choice
+
+    # @return [ModelProfile, nil] the profile given to the Engine, nil after a switch
+    attr_reader :given_profile
+
+    # The effective model's key (ModelOverlay.key_for its bare name), and
+    # the typed name's when that differs (#sync_model_key!).
+    # @return [String, nil]
+    attr_reader :model_key, :fallback_model_key
+
+    # Moves to +choice+ (Engine#switch_model!): the given profile and the
+    # kept resolution go with the old one.
+    def switch!(choice)
+      @mutex.synchronize do
+        # One assignment: a reader on another thread sees the old pair or the new one.
+        @choice = choice
+        # A profile given to .new was for the starting model.
+        @given_profile = nil
+        @resolution = nil
+      end
+    end
+
+    # Which profile the effective model gets and where that came from
+    # (ModelProfile.resolve: --profile/env, models:, hosts.<name>.profile,
+    # the server's chat template, the name, qwen36). Resolved on first need
+    # and kept, so the system prompt and the server's KV prefix stay stable;
+    # #switch! starts over, and a failed server probe is retried before
+    # the next turn (#refresh_profile!). The kernel follows each resolution.
+    # Kept with the model choice it was resolved for: one that finishes
+    # after a switch is neither kept nor applied (#store_profile).
+    # @return [ModelProfile::Resolution]
+    def profile_resolution
+      choice = @choice
+      cached = @resolution
+      return cached.last if cached&.first.equal?(choice)
+
+      store_profile(choice, resolve_profile(choice))
+    end
+
+    # +choice+'s profile (ModelProfile.resolve; may probe /props), or the
+    # one given to .new.
+    def resolve_profile(choice)
+      given = @given_profile
+      return ModelProfile::Resolution.new(profile: given, source: :given, detail: nil, retry: false) if given
+
+      EffectiveModel.of(@registry, choice).profile_resolution
+    end
+
+    # Keeps +resolution+ as +choice+'s and applies it, unless the model
+    # switched while it was resolved (a /stats on a Bridge thread probing
+    # as a /model ran): then it is only returned, and the new model's is
+    # resolved on its first need.
+    # @return [ModelProfile::Resolution]
+    def store_profile(choice, resolution)
+      @mutex.synchronize do
+        return resolution unless @choice.equal?(choice)
+
+        apply_profile(resolution)
+        @resolution = [choice, resolution]
+      end
+      resolution
+    end
+
+    # Everything that holds a profile follows the resolution: the kernel's
+    # prompt format and parser, and the system prompts built for the old one.
+    def apply_profile(resolution)
+      kept = @resolution&.last
+      @prompt_builder.call&.reset! if kept && kept.profile.name != resolution.profile.name
+      @kernel.call.use_profile!(resolution)
+      resolution
+    end
+
+    # Before a turn: resolve now if nothing has yet, or again if the last
+    # server probe failed (unreachable, or 503 while loading a model). A
+    # profile that changes here drops the cached system prompts.
+    def refresh_profile!
+      choice, kept = @resolution
+      return profile_resolution unless choice.equal?(@choice) && kept.retry?
+
+      store_profile(choice, resolve_profile(choice))
+    end
+
+    # The memory overlay key follows the model sent (ModelOverlay.key_for
+    # its id). A model typed as an alias used to key overlays by the alias
+    # (before aliases were applied there): that key is read when the
+    # target's overlay is missing (KernelLoop#sync_model_key!).
+    def sync_model_key!
+      choice = @choice
+      @model_key = ModelOverlay.key_for(@bare_name.call(choice.name))
+      typed_key = ModelOverlay.key_for(@registry.parse_qualified_model(choice.typed).last)
+      @fallback_model_key = typed_key == @model_key ? nil : typed_key
+      @kernel.call.sync_model_key!(@model_key, fallback: @fallback_model_key)
+    end
+  end
+end

data/lib/samagotchi/reminder_queue.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "monitor"
+require_relative "message_time"
 
 module Samagotchi
   # The session's due reminders, on their way into a turn.
@@ -11,9 +12,16 @@ module Samagotchi
   # turn while they are pending. A turn injects whatever is due then
   # (#inject!), which marks it fired and clears the pending names.
   class ReminderQueue
+    # The reminders message's first line at +time+ (a Time in the zone to
+    # show: Time.now's is the local one).
+    def self.header(time) = "[SYSTEM: REMINDERS DUE #{time.strftime("%Y-%m-%d %H:%M")} local]"
+
     # @param store [ReminderStore, nil]
-    def initialize(store:)
+    # @param now [#call] the wall clock (a Time) for the injected message's
+    #   stamp, when #inject! is given none
+    def initialize(store:, now: -> { MessageTime.now })
       @store = store
+      @now = now
       @lock = Monitor.new
       @pending = []
     end
@@ -55,14 +63,23 @@ module Samagotchi
     # A tail message, not the head system prompt: changing the head would
     # make the model server re-evaluate the whole conversation's prefix
     # (its KV cache) every interval; a tail costs only the new suffix.
+    # The header names the local time the reminders came due at, for the
+    # model ("[SYSTEM: REMINDERS DUE 2026-10-24 14:32 local]"): baked into
+    # the content here, never rendered at wire time, so a replay sends the
+    # same bytes (the prompt cache) whatever the time zone or DST. The
+    # message also carries that time as its stamp (MessageTime::KEY,
+    # display-only).
     # @param messages [Array<Hash>] the turn's messages (appended to)
+    # @param now [Time, nil] the turn's wall time (nil: the clock's)
     # @return [Array<Hash>] the reminders injected (maybe none)
-    def inject!(messages)
+    def inject!(messages, now: nil)
       reminders = due
       return [] if reminders.empty?
 
+      time = now || @now.call
       lines = reminders.map { |r| "  #{r[:name]}: #{r[:description]} (interval: #{r[:interval_minutes]}m)" }.join("\n")
-      messages << { role: "system", content: "[SYSTEM: REMINDERS DUE]\n#{lines}\n[END REMINDERS]" }
+      messages << { role: "system", content: "#{self.class.header(time)}\n#{lines}\n[END REMINDERS]",
+                    MessageTime::KEY => MessageTime.iso(time) }
       @store.mark_fired_batch(reminders.map { |r| r[:name] })
       # Without this a turn's injection leaves a stale name, and the next
       # reminder turn would run with nothing due.

data/lib/samagotchi/reply_wait/poll.rb

@@ -27,7 +27,7 @@ module Samagotchi
         @ended_before = ended_before
         @deadline = timeout && (ReplyWait.monotonic + timeout.to_f)
         @turn = turn.to_s.empty? ? nil : turn.to_s
-        @session_dir = Session.session_dir(id, state_dir: state_dir) if @turn
+        @session_dir = Session.session_dir(id, state_dir: state_dir)
         # 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.
@@ -40,6 +40,11 @@ module Samagotchi
         @seen_own = false
         @own_base = nil
         @seen_running = false
+        # A turn seen running with its checkpoint mark (a wait with no
+        # turn:): last_turn's ended_at then and the input files claimed
+        # then, so its settle by a next worker (#settled_running) tells
+        # from a turn that ended or an input that runs next.
+        @running_look = nil
         @gone_since = nil
       end
 
@@ -216,8 +221,13 @@ module Samagotchi
 
         if running?(session)
           @seen_running = true
+          note_running(session)
           return nil
         end
+        if (settled = settled_running(session))
+          return settled
+        end
+
         # It ran and is idle again with no new reply: canceled, failed or
         # empty. Before it was ever seen running, idle means a
         # file-delivered message its worker has not picked up yet. With a
@@ -254,6 +264,34 @@ module Samagotchi
         nil
       end
 
+      RunningLook = Data.define(:last_end, :claimed)
+
+      def note_running(session)
+        return unless session.interrupted_turn
+
+        @running_look = RunningLook.new(last_end: session.last_turn&.ended_at,
+                                        claimed: SessionInbox.claimed_input_files(@session_dir))
+      end
+
+      # The turn seen running is gone with no turn's end: its worker died
+      # in it and the next one settled it (TurnCheckpoint.settle: idle, the
+      # mark gone, last_turn left alone), which ends a wait for it (chi
+      # send --wait with no message, a message merged into it as a steer)
+      # as canceled, worker_stopped, rather than at the timeout. Not while
+      # an input waits or a new one was claimed since (the sent message,
+      # unmerged, runs as its own turn next: its end is the answer), nor
+      # for a settle never seen running (a message sent to a session a dead
+      # worker left running goes in after the settle).
+      def settled_running(session)
+        look = @running_look
+        return nil unless look && session.status == Session::STATUS_IDLE && session.interrupted_turn.nil? &&
+                          session.last_turn&.ended_at == look.last_end
+        return nil unless SessionInbox.find_new_input_files(@session_dir).empty?
+        return nil unless (SessionInbox.claimed_input_files(@session_dir) - look.claimed).empty?
+
+        Result.new(status: :no_reply, outcome: "canceled", cancel_reason: TurnCheckpoint::WORKER_STOPPED, session: session)
+      end
+
       def owner_gone(session)
         return nil unless @owner_grace
 

data/lib/samagotchi/run_options.rb

@@ -14,7 +14,7 @@ module Samagotchi
   module RunOptions
     # The flags an underscored spelling is refused for (--recap_base_url),
     # with the config registry's.
-    KNOWN = %w[--prompt --resume --attach --shared --no-shared --model --thinking --toolkit --tool --no-tool --set --parent-answers --memory --mute --append-system-prompt --dir --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token].freeze
+    KNOWN = %w[--prompt --resume --attach --shared --no-shared --model --thinking --toolkit --tool --no-tool --set --parent-answers --memory --mute --append-system-prompt --dir --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token --tunnel].freeze
 
     module_function
 
@@ -219,6 +219,9 @@ module Samagotchi
         opts.on("--port PORT", "Port for `chi web` (default: 4567, env SAMAGOTCHI_WEB_PORT)") { |p| options[:web_port] = p.to_i; cli_overrides["web.port"] = p.to_s }
         opts.on("--open", "Open browser for `chi web`") { options[:web_open] = true }
         opts.on("--new-token", "`chi web`: replace the LAN access token (web.host: lan); links and QR codes made with the old one stop working") { options[:new_token] = true }
+        opts.on("--tunnel PROVIDER", %w[tailscale],
+                "`chi web`: reach it over https from your tailnet through Tailscale Serve (never Funnel), for this run; " \
+                "turned off on exit") { |v| options[:tunnel] = v }
         opts.on("--scope VALUE", %w[project all],
                 "Which sessions `chi web` and `chi sessions list` show: project (the default: this folder's git project; " \
                 "every session outside a repo) or all") { |v| options[:scope] = v }

data/lib/samagotchi/send_command/wait_target.rb

@@ -19,11 +19,18 @@ module Samagotchi
       # settle end the wait (TurnCheckpoint.settled_turn). A message merged
       # into a turn starting then falls back to that turn's reply
       # (ReplyWait's turn: without queued:); no id (an older worker), the
-      # next reply.
+      # next reply. A prompt the session was created with has no delivery:
+      # its turn is the id the create gave it (+direct_turn+,
+      # Session#first_turn_id), and nothing can merge into it, so the wait
+      # is for that turn alone (ReplyWait's queued:).
       # @param delivered [SessionManager::DeliverResult, nil] nil when the
       #   message started the session itself (no delivery)
-      def self.first_message(delivered)
-        return new unless delivered
+      # @param direct_turn [String, nil] that first turn's id, for a direct
+      #   start
+      def self.first_message(delivered, direct_turn: nil)
+        return new unless delivered || !direct_turn.to_s.strip.empty?
+
+        return new(turn: direct_turn, report_turn_id: direct_turn, queued: true) if delivered.nil?
 
         new(turn: delivered.enqueued_id, report_turn_id: delivered.enqueued_id)
       end

data/lib/samagotchi/send_command.rb

@@ -521,7 +521,8 @@ module Samagotchi
 
       start = @access.prepare_wait(session.id, session: session, created: true)
       wait_for_reply(session.id, cursor: start.cursor, baseline: start.baseline,
-                                 timeout: options[:timeout], **WaitTarget.first_message(@delivered).to_h)
+                                 timeout: options[:timeout],
+                                 **WaitTarget.first_message(@delivered, direct_turn: session.first_turn_id).to_h)
     end
 
     # What chi send --new asks to create: through the worker (images, a

data/lib/samagotchi/session.rb

@@ -54,6 +54,13 @@ module Samagotchi
     attr_accessor :id, :metadata_version, :mode, :model_name, :working_directory, :messages,
                   :created_at, :updated_at, :status, :last_prompt, :first_preview, :test_run,
                   :used_memory_names
+    # The id the prompt a session is created with gets (SessionManager
+    # .spawn_session), so its first turn is a turn with an id like one sent
+    # later: the worker's first turn takes it as its origin, its reply file
+    # and last_turn carry it, and a wait for it (`chi send --new --wait`,
+    # chi web's create) can name it (`--wait --turn T ID`). nil for a
+    # session created idle, and for one saved before the field existed.
+    attr_accessor :first_turn_id
     # Memories the session was started with (--memory) and memories hidden
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.
@@ -310,7 +317,7 @@ module Samagotchi
 
     def initialize(id:, mode:, model_name:, working_directory:, messages:, created_at:, updated_at:,
                    metadata_version: METADATA_VERSION, status: STATUS_IDLE, last_prompt: "",
-                   first_preview: "", test_run: false, pending_question: nil,
+                   first_preview: "", first_turn_id: nil, 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: [],
@@ -329,6 +336,7 @@ module Samagotchi
       @status = status
       @last_prompt = last_prompt
       @first_preview = first_preview
+      @first_turn_id = first_turn_id
       @title = title
       @test_run = !!test_run
       self.pending_question = pending_question
@@ -525,12 +533,13 @@ module Samagotchi
       "interrupted_turn" => nil,
       "parent_answers" => nil,
       "working_set_pins" => [],
-      "review" => nil
+      "review" => nil,
+      "first_turn_id" => nil
     }.freeze
 
     # FIELDS a session file has only when set: a session without them saves
     # as it did before they existed.
-    OPTIONAL_FIELDS = %w[review].freeze
+    OPTIONAL_FIELDS = %w[review first_turn_id].freeze
 
     # A session from a parsed session file. +messages+ false leaves the
     # conversation out (the lists' lightweight summaries).

data/lib/samagotchi/session_access/contract.rb

@@ -150,7 +150,7 @@ module Samagotchi
                         --llm-context-budget --toolkit --tool --no-tool --set --parent-answers --no-interrupt
                         --no-default-input --dir --version -h --help],
         LOCAL_ONLY => %w[--no-shared --non-interactive -v --verbose --append-system-prompt --memory --mute --profile
-                         --port --open --new-token --scope --web-markdown --no-web-markdown]
+                         --port --open --new-token --tunnel --scope --web-markdown --no-web-markdown]
       }.freeze
       # A short run flag's name in a refusal.
       RUN_WORDS = { "-v" => "--verbose" }.freeze

data/lib/samagotchi/session_access/local.rb

@@ -364,8 +364,9 @@ module Samagotchi
       end
 
       # The link names this machine's chi web: web.public_url from this
-      # machine's config (never what the port answers) when it is set (the
-      # token in the fragment, as chi web's own invite), else its LAN address
+      # machine's config (never what the port answers) when it is set, or
+      # the one a running chi web --tunnel recorded (the code in the
+      # fragment, as chi web's own invite), else its LAN address
       # and port when one runs on the LAN (the port it recorded, else
       # web.port), else 127.0.0.1 (+lan+ false: the link opens on this
       # machine only).
@@ -431,10 +432,15 @@ module Samagotchi
         Web::LinkCodes.for_grants(grants.path).issue(kind: :grant, token: issued.token, ttl: ttl)
       end
 
-      # web.public_url as this machine's config has it; nil when unset or
-      # not a valid one (chi web refuses to start on that).
+      # web.public_url as this machine's config has it (nil when not a
+      # valid one: chi web refuses to start on that), else the one the
+      # running chi web recorded (chi web --tunnel's), only while that same
+      # process answers on its port (Web::Running.live_public_url).
       def configured_public_url
-        Web::PublicUrl.from_config(url: Config.get("web.public_url"))
+        configured = Config.get("web.public_url")
+        return Web::Running.live_public_url(path: Web::Running.path(state_dir: state_dir!)) if configured.to_s.strip.empty?
+
+        Web::PublicUrl.from_config(url: configured)
       rescue Web::PublicUrl::Invalid
         nil
       end

data/lib/samagotchi/session_access/remote.rb

@@ -179,7 +179,8 @@ module Samagotchi
 
         json = reply.json
         Created.new(id: json.fetch("id"), model_warning: json["model_warning"], continues: json["continues"],
-                    moved_children: json["moved"] || [], parent_answers_warning: json["parent_answers_warning"])
+                    moved_children: json["moved"] || [], parent_answers_warning: json["parent_answers_warning"],
+                    first_turn_id: json["first_turn_id"])
       end
 
       # Whether a just-created session's worker came up within +timeout+

data/lib/samagotchi/session_access.rb

@@ -160,9 +160,13 @@ module Samagotchi
 
     # What chi send --new created (Remote; Local gives the Session): its
     # id, a model warning, the session it continues, the delegates it took
-    # over, and the server's word on a --parent-answers looser than its
-    # config.yml's (capped).
-    Created = Data.define(:id, :model_warning, :continues, :moved_children, :parent_answers_warning)
+    # over, the server's word on a --parent-answers looser than its
+    # config.yml's (capped), and the id the prompt it started with gets for
+    # its first turn (nil for one created idle).
+    Created = Data.define(:id, :model_warning, :continues, :moved_children, :parent_answers_warning, :first_turn_id) do
+      def initialize(id:, model_warning: nil, continues: nil, moved_children: [], parent_answers_warning: nil,
+                     first_turn_id: nil) = super
+    end
 
     # A session's worker as an attach finds it (Local#worker, chi web's GET
     # …/worker): +sidecar+ the live worker's WorkerSidecar (port, version,

data/lib/samagotchi/session_inbox.rb

@@ -371,10 +371,14 @@ module Samagotchi
       claimed_input?(session_dir, id) ? [:claimed, nil] : [:none, nil]
     end
 
-    # Whether a claimed input file (*.json.processing: a turn's, now or
-    # left by a crash, or a removal's before it deletes it) carries +id+.
+    # The claimed input files (*.json.processing: a turn's, now or left by
+    # a crash, or a removal's before it deletes it).
+    # @return [Array<String>] their paths
+    def self.claimed_input_files(session_dir) = Dir.glob(File.join(session_dir, INPUT_DIR, "*.json.processing"))
+
+    # Whether a claimed input file carries +id+.
     def self.claimed_input?(session_dir, id)
-      Dir.glob(File.join(session_dir, INPUT_DIR, "*.json.processing")).any? do |file|
+      claimed_input_files(session_dir).any? do |file|
         data = JSON.parse(File.read(file))
         data.is_a?(Hash) && data["enqueued_id"] == id
       rescue JSON::ParserError, SystemCallError

data/lib/samagotchi/session_manager.rb

@@ -197,6 +197,11 @@ module Samagotchi
       # the prompts), so the session starts idle.
       session.status = prompt.to_s.strip.empty? ? Session::STATUS_IDLE : Session::STATUS_RUNNING
       session.last_prompt = prompt
+      # The first prompt's turn gets an id like a sent message's, so a wait
+      # for it can name it (chi send --new --wait, chi web's create): the
+      # worker runs it with that origin, and its reply file and last_turn
+      # carry the id.
+      session.first_turn_id = SecureRandom.uuid unless prompt.to_s.strip.empty?
       # The worker takes last_prompt and clears it, and messages are saved at
       # the turn's end: until then this is the only preview a list has.
       session.first_preview = Session.preview_of(preview.to_s.strip.empty? ? prompt : preview)

data/lib/samagotchi/steer.rb

@@ -2,6 +2,7 @@
 
 require_relative "client_id"
 require_relative "participant_name"
+require_relative "message_time"
 
 module Samagotchi
   # A plugin's steer: text a plugin puts into the running turn (Engine#steer),
@@ -53,15 +54,16 @@ module Samagotchi
 
       # The messages it appends: the merged input first (one message per
       # sender run, marked kind input, source: when not the user's), then
-      # each steer.
-      def messages
+      # each steer; all stamped with +at+ (MessageTime::KEY), the drain's
+      # wall time.
+      def messages(at: MessageTime.iso(MessageTime.now))
         list = inputs.map do |input|
           message = { role: "user", kind: INPUT_KIND }
           message[:source] = input[:source] if input[:source]
           message.merge!(input[:mark]) if input[:mark]
           message.merge(content: input[:content], **Steer.author_fields(input[:author], input[:author_name]))
         end
-        list + steers.map { |steer| Steer.message(**steer) }
+        (list + steers.map { |steer| Steer.message(**steer) }).map { |message| MessageTime.stamp(message, at) }
       end
 
       # The :pending_input_merged fields beside iteration and answer;