samagotchi 0.109.0 → 0.110.0

data/lib/samagotchi/idle_recap.rb

@@ -504,7 +504,7 @@ module Samagotchi
                 model: served || job[:model], created_at: Time.now.utc.iso8601 }
       @mutex.synchronize { @state = saved }
       save(saved)
-      @engine.emit_recap(recap: text, generation: job[:generation], covered: job[:covered])
+      @engine.emit_recap(recap: text, generation: job[:generation], covered: job[:covered], created_at: saved[:created_at])
     rescue StandardError
       @in_flight = nil
     end

data/lib/samagotchi/idle_reminders.rb

@@ -8,7 +8,7 @@ module Samagotchi
   #
   # Two delivery paths cooperate:
   #   1. Every turn injects what is due (ReminderQueue#inject!, from
-  #      Engine#run_turn) as [SYSTEM: REMINDERS DUE] and marks it fired.
+  #      Engine#run_turn) as [SYSTEM: REMINDERS DUE <local time>] and marks it fired.
   #   2. Synthetic turns: when this job's tick finds due reminders while
   #      idle, it fires @auto_turn_callback, which queues their names
   #      (Engine#note_due_reminders) for the worker's or the REPL's

data/lib/samagotchi/kernel_loop.rb

@@ -33,6 +33,7 @@ require_relative "llm_context_forget"
 require_relative "working_set"
 require_relative "llm_context_notice"
 require_relative "answer_display"
+require_relative "message_time"
 require_relative "llm/model_result"
 require_relative "llm/turn_settings"
 require_relative "llm/stream_drops"
@@ -360,7 +361,8 @@ module Samagotchi
         return after_malformed(turn, generation, reason)
       end
 
-      turn.conversation << { role: "model", content: request.prefill + generation.response.to_s }
+      turn.conversation << { role: "model", content: request.prefill + generation.response.to_s,
+                             MessageTime::KEY => MessageTime.iso(MessageTime.now) }
       # Profile-specific parse (incl. Qwen unterminated-block recovery); the
       # returned fragment (non-nil only for Qwen) is fed back on the next
       # iteration if the model opened a tool-call block it did not close.
@@ -867,7 +869,8 @@ module Samagotchi
       # cannot leak) so a follow-up steering message continues with the model's
       # half-finished work in context instead of losing it.
       unless partial.empty?
-        message = { role: "model", content: "#{partial}\n[interrupted]", interrupted: true }
+        message = { role: "model", content: "#{partial}\n[interrupted]", interrupted: true,
+                    MessageTime::KEY => MessageTime.iso(MessageTime.now) }
         # The thinking this generation streamed goes with it (the chat loop's
         # with_thinking key, which MessageParts reads and the prompt doesn't):
         # without it, reloading the cut step shows the empty answer it isn't.
@@ -1088,16 +1091,18 @@ module Samagotchi
 
     # +keep_thought_from+: model messages from this index on keep their
     # thought blocks (a resumed run's); nil strips every one.
+    # A model message is rebuilt from an allow-list: `display`,
+    # `display_refs` and its wall time (MessageTime::KEY) ride along so the
+    # stored conversation keeps them; the prompt formatter never reads them
+    # (AnswerDisplay, AnswerRefs, MessageTime).
     def sanitize_history(messages, keep_thought_from: nil)
       messages.each_with_index.map do |m, index|
         if m[:role] == "model" && keep_thought_from && index >= keep_thought_from
-          { role: m[:role], content: m[:content].to_s, display: m[:display], display_refs: m[:display_refs] }.compact
+          { role: m[:role], content: m[:content].to_s, display: m[:display], display_refs: m[:display_refs],
+            MessageTime::KEY => m[MessageTime::KEY] }.compact
         elsif m[:role] == "model"
-          # `display` and `display_refs` ride along so the stored
-          # conversation keeps them; the prompt formatter never reads them
-          # (AnswerDisplay, AnswerRefs).
           { role: m[:role], content: strip_thought_blocks(m[:content].to_s), display: m[:display],
-            display_refs: m[:display_refs] }.compact
+            display_refs: m[:display_refs], MessageTime::KEY => m[MessageTime::KEY] }.compact
         else
           m.dup
         end

data/lib/samagotchi/llm/chat_loop.rb

@@ -30,6 +30,7 @@ require_relative "../empty_answer_retry"
 require_relative "../steer"
 require_relative "../reasoning_history"
 require_relative "../turn_note"
+require_relative "../message_time"
 require_relative "../thinking"
 
 module Samagotchi
@@ -432,7 +433,8 @@ module Samagotchi
       # note's marker (TurnNote.empty, never sent), and an answer's display
       # and display_refs (AnswerDisplay, AnswerRefs; never sent), a
       # find_tools result's loaded names and a tool change's TOOL_CHANGE
-      # (sent only to a wire that loads tools).
+      # (sent only to a wire that loads tools), and an entry's wall time
+      # (MessageTime::KEY, display-only, never sent).
       def plain(conversation)
         conversation.map do |entry|
           content = entry[:content].is_a?(Array) ? entry[:content] : entry[:content].to_s
@@ -454,6 +456,7 @@ module Samagotchi
           Steer::AUTHOR_KEYS.each { |key| message[key] = entry[key] if entry[key] }
           message[ToolResponse::LOADED] = entry[ToolResponse::LOADED] if entry[ToolResponse::LOADED].is_a?(Array)
           message[TOOL_CHANGE] = entry[TOOL_CHANGE] if entry[TOOL_CHANGE].is_a?(Hash)
+          message[MessageTime::KEY] = entry[MessageTime::KEY] if entry[MessageTime::KEY]
           message
         end
       end
@@ -704,7 +707,10 @@ module Samagotchi
         # (reasoning_history). A wire that sends its blocks back keeps them
         # as +anthropic_content+ (ChatResponse#provider_content: string
         # keys, as received, so a resumed session sends the same bytes).
+        # Every reply built from a response comes through here, so it is
+        # also where a reply gets its wall time (MessageTime::KEY).
         def with_thinking(message, response)
+          MessageTime.stamp(message, MessageTime.now)
           reasoning = response.reasoning.to_s
           message = message.merge(thinking: reasoning) unless reasoning.strip.empty?
           blocks = response.provider_content
@@ -1038,7 +1044,8 @@ module Samagotchi
           emit(type: :generation_cancelled, iteration: iteration, reason: reason, stopped_by: @cancel_controller&.stopped_by)
           visible = @loop.strip_model_thought(partial.to_s).strip
           unless visible.empty?
-            message = { role: "model", content: "#{visible}\n[interrupted]", interrupted: true }
+            message = { role: "model", content: "#{visible}\n[interrupted]", interrupted: true,
+                        MessageTime::KEY => MessageTime.iso(MessageTime.now) }
             thought = thinking.to_s
             message[:thinking] = thought unless thought.strip.empty?
             @conversation << message

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/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/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_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/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;

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -14,6 +14,7 @@ require_relative "line_reader"
 require_relative "question_prompt"
 require_relative "reline_seam"
 require_relative "version_lines"
+require_relative "gap_clock"
 require_relative "participant_commands"
 require_relative "local_link"
 require_relative "../bridge/turn_accumulator"
@@ -100,6 +101,7 @@ module Samagotchi
       # @param default_input [Boolean] type SAMAGOTCHI_DEFAULT_INPUT into
       #   the first read (a new session with no -p, as the REPL)
       # @param clock [#call] monotonic seconds (the Ctrl-C detach window)
+      # @param now [#call] the wall clock, a Time (the gap dividers)
       # @param delete_session [#call] session id -> deletes it (/exit --delete)
       # @param archive_session [#call] session id -> archives it (/archive);
       #   SessionManager.archive_session's result
@@ -114,7 +116,7 @@ module Samagotchi
       #   +client+ and the keywords that make a LocalLink
       def initialize(screen:, client_id:, client: nil, first_prompt: nil, first_command: nil, no_interrupt: false,
                      default_input: false, wait_at_eof: false, as_parent: false,
-                     clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
+                     clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }, now: -> { MessageTime.now },
                      delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: LocalLink::DELETE_WAIT) },
                      archive_session: ->(id) { SessionManager.archive_session(id, wait: LocalLink::DELETE_WAIT) },
                      installed_version: -> { InstalledVersions.new.newest },
@@ -152,6 +154,8 @@ module Samagotchi
         @no_interrupt = no_interrupt
         @no_default_input = !default_input
         @clock = clock
+        # The session's last activity, for the gap dividers (GapClock).
+        @gaps = GapClock.new(now: now)
         @last_idle_interrupt_at = nil
         @next_input_prefill = nil
         # Prompts this run sent, by enqueued_id: only those come back into
@@ -208,7 +212,12 @@ module Samagotchi
         end
         read = input || method(:read_input_line)
         # A command typed after /unqueue's text echoes as the command alone.
-        echoed_read = ->(prompt, prefill) { RelineSeam.echo_as(method(:prefilled_echo)) { read.call(prompt, prefill) } }
+        # A typed prompt after a quiet gap has its divider above its echo.
+        echoed_read = lambda do |prompt, prefill|
+          RelineSeam.echo_as(method(:prefilled_echo)) do
+            RelineSeam.echo_above(method(:gap_above_echo)) { read.call(prompt, prefill) }
+          end
+        end
         @reader = LineReader.new(queue, prompt: method(:prompt_text), read: echoed_read, prefill: default_input_text).start
         loop do
           kind, payload = next_item(queue)
@@ -280,10 +289,12 @@ module Samagotchi
         when :turn_dequeued then turn_dequeued(event)
         when :turn_started
           @status.take_event(event)
+          mark_activity
           start_turn(event)
         when :turn_completed
           @status.take_event(event)
           complete_turn(event)
+          @gaps.touch
           refresh_children
           own_turn_ended(event)
         # The renderer says how it ended (the REPL's words too).
@@ -291,6 +302,7 @@ module Samagotchi
           @status.take_event(event)
           @renderer.call(event)
           end_turn
+          @gaps.touch
           refresh_children
           own_turn_ended(event)
         when :prompt_restored then restore_prompt(event)
@@ -307,10 +319,14 @@ module Samagotchi
         when :command_ran
           command_ran(event)
           return first_command_ran(event) if @first_command_id && event[:command_id] == @first_command_id
-        when :reminder_injected then @screen.commit(reminder_line(event[:reminders]))
+        when :reminder_injected
+          mark_activity
+          @screen.commit(reminder_line(event[:reminders]))
         # A context note joined the conversation (between turns). One dim
         # line in the scrollback; the notes slot is for question choices.
-        when :context_added then @screen.commit(context_note_line(event[:label], event[:text]))
+        when :context_added
+          mark_activity
+          @screen.commit(context_note_line(event[:label], event[:text]))
         when :continue_offered then offer_continue(event)
         when :continue_resolved then continue_resolved(event)
         # The note comes with the kernel's :pending_input_merged (EventRenderer),
@@ -331,7 +347,7 @@ module Samagotchi
         when :question_relay then question_relayed(event)
         # Written while the session sat idle: shown at the open prompt. One
         # collected just as a turn started describes the chat before it.
-        when :recap_ready then @screen.commit(recap_block(event[:recap])) unless @running || event[:recap].to_s.strip.empty?
+        when :recap_ready then show_recap_ready(event) unless @running || event[:recap].to_s.strip.empty?
         when :guardrail_warning then @screen.commit(EventRenderer.load_warning_line(event))
         # A plugin's slow setup: the activity row turns while it runs; a
         # line when it is done (a failure is a warn card).
@@ -359,6 +375,32 @@ module Samagotchi
 
       private
 
+      # A recap written while idle, with the time it was written.
+      def show_recap_ready(event)
+        mark_activity
+        @screen.commit(recap_block(event[:recap], at: event[:created_at]))
+      end
+
+      # Activity starts now: a gap's divider first when one passed since the
+      # last (none while a turn runs: its steps are no gap).
+      def mark_activity
+        line = @gaps.divider(quiet: @running)
+        @screen.commit(gap_divider(line)) if line
+      end
+
+      # The divider above a typed line's echo (RelineSeam.echo_above, on the
+      # reader thread): a prompt typed after a quiet gap, at an idle prompt.
+      # It marks the activity, so the turn's start marks no second one.
+      def gap_above_echo(text)
+        return nil if @running
+
+        route = ComposerRoute.call(text.to_s.strip, running: false, registry: command_registry)
+        return nil unless %i[prompt deliver].include?(route.kind)
+
+        line = @gaps.divider
+        line && gap_divider(line)
+      end
+
       # The newest chi installed, looked at once, at the join.
       def installed_version
         @link.installed_version
@@ -936,6 +978,9 @@ module Samagotchi
         return own_prompt_failed if images.nil?
 
         running = @running
+        # Off a live region (no echo seam) the divider comes here; after
+        # #gap_above_echo it marks none.
+        mark_activity
         options = { prompt: text, client_id: client_id_for(text) }
         options[:no_interrupt] = true if @no_interrupt
         options[:images] = images unless images.empty?
@@ -1315,8 +1360,9 @@ module Samagotchi
           @attached = true
           # The recap first: what the session was about, then where it stopped.
           saved = snapshot[:saved_recap]
-          @screen.commit(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved && !saved[:text].to_s.strip.empty?
+          @screen.commit(recap_block(saved[:text], turns_since: saved[:turns_since], at: saved[:created_at])) if saved && !saved[:text].to_s.strip.empty?
           render_join_header(Array(snapshot[:messages]))
+          render_join_gap(snapshot, saved)
           @screen.commit("guardrails> #{snapshot[:guardrail_warning]}") if snapshot[:guardrail_warning]
           @screen.commit("plugins> #{snapshot[:plugin_warning]}") if snapshot[:plugin_warning]
           version_line = VersionLines.at_attach(worker: snapshot[:chi_version], installed: installed_version,
@@ -1431,6 +1477,17 @@ module Samagotchi
         end
       end
 
+      # Where the session's last activity was: its newest stamped entry,
+      # else its saved recap's time. A gap ago (and no turn running): one
+      # line after the join block says when.
+      def render_join_gap(snapshot, saved)
+        @gaps.seed(snapshot[:messages], fallback: saved&.dig(:created_at))
+        return if snapshot[:current_turn]
+
+        line = @gaps.join_line
+        @screen.commit(gap_divider(line)) if line
+      end
+
       def render_join_header(messages)
         exchange = messages.select { |m| %w[user model assistant].include?(m[:role].to_s) }
         # The id stays findable: the detach line and chi sessions list show it.
@@ -1537,17 +1594,19 @@ module Samagotchi
       # A saved call's row; "no result" for a call the turn never answered
       # (it ended first). Its status is the saved record's, as live and the
       # web's reload (a guardrail's "blocked" is no error), else read from
-      # its result.
+      # its result (a guardrail's deny text reads blocked too).
       def join_tool_line(part, duration_ms: nil, saved_status: nil)
         output = part[:output]
         command = part.dig(:view, :truncated) ? nil : part.dig(:view, :command)
+        text = ToolActivity.saved_result_text(output) unless output.nil?
         status = if output.nil?
                    "no result"
                  elsif !saved_status.to_s.empty?
                    saved_status.to_s
+                 elsif ToolActivity.guardrail_denied?(text)
+                   "blocked"
                  else
-                   ToolActivity.tool_activity_status(ToolActivity.saved_result_text(output), part[:tool],
-                                                     command: command)
+                   ToolActivity.tool_activity_status(text, part[:tool], command: command)
                  end
         activity = { action: part[:label] || ToolActivity.tool_activity_action(part[:tool]), tool: part[:tool],
                      params: part[:params], status: status,
@@ -1658,6 +1717,8 @@ module Samagotchi
       def show_enqueued(event)
         return if own?(event[:client_id])
 
+        # Another client's prompt shows here, before its turn starts.
+        mark_activity
         @shown_enqueued << event[:enqueued_id]
         line = prompt_line(event[:client_id], event[:prompt], **author_of(event[:author]))
         @screen.commit(event[:delivery] == Delivery::QUEUE ? "#{line} #{QUEUED_NOTE}" : line)