samagotchi 0.109.0 → 0.110.0

data/lib/samagotchi/terminal_ui/between_turns.rb

@@ -26,7 +26,9 @@ module Samagotchi
       # @param renderer [EventRenderer] draws cards
       # @param turn_running [#call] whether a turn runs now
       # @param quiet [Boolean] a --non-interactive run: no init lines
-      def initialize(surface:, view:, renderer:, turn_running:, quiet: false)
+      # @param gaps [GapClock, nil] the session's last activity: a recap
+      #   after a quiet gap has its divider
+      def initialize(surface:, view:, renderer:, turn_running:, quiet: false, gaps: nil)
         @surface = surface
         @view = view
         @renderer = renderer
@@ -34,6 +36,7 @@ module Samagotchi
         @quiet = quiet
         @cards = Queue.new
         @recap = nil
+        @gaps = gaps
       end
 
       attr_writer :surface
@@ -84,7 +87,7 @@ module Samagotchi
         return unless event[:type] == :recap_ready
         return if event[:recap].to_s.strip.empty? || turn_running?
 
-        @recap = event[:recap].to_s
+        @recap = { text: event[:recap].to_s, at: event[:created_at] }
       end
 
       # Print a recap written while idle (main thread, at the open prompt).
@@ -93,7 +96,9 @@ module Samagotchi
         return unless recap
 
         @recap = nil
-        @surface.commit(recap_block(recap))
+        line = @gaps&.divider
+        @surface.commit(gap_divider(line)) if line
+        @surface.commit(recap_block(recap[:text], at: recap[:at]))
       end
 
       # Print the cards, notices and anytime commands' output kept since the

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -11,6 +11,7 @@ require_relative "../memory_bundle/index_size"
 require_relative "../prompt_note"
 require_relative "../prompt_files"
 require_relative "../session_config"
+require_relative "../message_time"
 require_relative "../tools/task_record"
 require_relative "model_segments_text"
 
@@ -513,19 +514,26 @@ module Samagotchi
 
       private
 
-      # The recap shown on return: dim, one "recap>" block, noting how many
-      # turns came since it was written.
-      def recap_block(text, turns_since: 0)
+      # The recap shown on return: dim, one "recap>" block, with the local
+      # time it was written ("recap 14:32>") when known, noting how many
+      # turns came since.
+      # @param at [String, nil] its created_at (an ISO time, any offset)
+      def recap_block(text, turns_since: 0, at: nil)
         n = turns_since.to_i
         note = if n == 1 then " (before the last turn)"
                elsif n > 1 then " (before the last #{n} turns)"
                else ""
                end
+        clock = MessageTime.clock(at)
+        head = clock ? "recap #{clock}#{note}>" : "recap#{note}>"
         text.to_s.strip.lines.map(&:chomp).each_with_index.map do |line, i|
-          paint(i.zero? ? "recap#{note}> #{line}" : line, 90)
+          paint(i.zero? ? "#{head} #{line}" : line, 90)
         end.join("\n")
       end
 
+      # A quiet gap's divider (MessageTime.gap_line, GapClock#join_line): dim.
+      def gap_divider(text) = paint(text, 2)
+
       RECAP_OFF_TEXT = "recap is off (recap: false in config.yml, or SAMAGOTCHI_RECAP_ENABLED=false; /recap on turns it on here)"
       # Off by the session's own recap.enabled (/recap off, --set recap.enabled=false).
       RECAP_SESSION_OFF_TEXT = "recap is off for this session (/recap on turns it on, /recap default goes back to config.yml)"
@@ -540,7 +548,7 @@ module Samagotchi
 
         saved = saved&.transform_keys(&:to_sym)
         lines = []
-        lines << recap_block(saved[:text], turns_since: saved[:turns_since]) if saved
+        lines << recap_block(saved[:text], turns_since: saved[:turns_since], at: saved[:created_at]) if saved
         lines << case request&.to_sym
                  when :started, :in_flight then "writing a recap…"
                  when :nothing_new then saved ? "(nothing new since this recap)" : "no recap yet: nothing to recap"

data/lib/samagotchi/terminal_ui/gap_clock.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../message_time"
+
+module Samagotchi
+  class TerminalUI
+    # When the session's last activity was, for both TUIs' gap dividers: a
+    # dim "── 14:32 · 47 min later ──" before what comes after a quiet
+    # MessageTime::GAP_SECONDS. Activity is a prompt (typed or another
+    # client's), a reminder, a context note, a recap, and a turn's end; a
+    # gap is measured from the end of one to the start of the next, so a
+    # long turn followed at once by another marks nothing.
+    #
+    # The times are this terminal's wall clock when it saw them (+now+),
+    # seeded at the join from the session's stamped history. Read from the
+    # reader thread too (a typed prompt's divider goes above its echo), so
+    # every read-and-mark is under one lock.
+    class GapClock
+      # @param now [#call] the wall clock (a Time); MessageTime.now, which
+      #   the specs pin, by default
+      def initialize(now: -> { MessageTime.now })
+        @now = now
+        @last = nil
+        @lock = Mutex.new
+      end
+
+      # @return [String] now, as a stamp
+      def now_iso = MessageTime.iso(@now.call)
+
+      # Mark activity starting now.
+      # @param quiet [Boolean] mark only, no divider (a turn runs: its own
+      #   steps are no gap)
+      # @return [String, nil] the divider's text when a gap passed since
+      #   the last activity
+      def divider(quiet: false)
+        @lock.synchronize do
+          now = now_iso
+          line = quiet ? nil : MessageTime.gap_line(@last, now)
+          @last = now
+          line
+        end
+      end
+
+      # Mark activity (a turn's end) without a divider.
+      def touch = divider(quiet: true)
+
+      # Start from the session's last activity (the join, a resume): the
+      # newest stamp in +messages+ (Symbol- or String-keyed), else
+      # +fallback+ (a saved recap's created_at). Nothing known: nothing set.
+      # @return [String, nil] the time it started from
+      def seed(messages, fallback: nil)
+        iso = Array(messages).reverse_each.lazy.filter_map { |m| MessageTime.of(m) }.first || fallback
+        iso = MessageTime.iso_of(iso)
+        @lock.synchronize { @last = iso } if iso
+        iso
+      end
+
+      # The join's line when the last activity is a gap ago:
+      # "── last activity 14:32 · 47 min ago ──" (the date when the local
+      # day changed). Printed, it stands for the gap: the clock moves to now,
+      # so the next prompt marks none.
+      # @return [String, nil]
+      def join_line
+        @lock.synchronize do
+          now = now_iso
+          next nil unless MessageTime.gap_line(@last, now)
+
+          last = Time.iso8601(@last).localtime
+          same_day = last.to_date == Time.iso8601(now).localtime.to_date
+          time = same_day ? MessageTime.clock(@last) : MessageTime.day_clock(@last)
+          line = "── last activity #{time} · #{MessageTime.ago(Time.iso8601(now) - last)} ago ──"
+          @last = now
+          line
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui/reline_seam.rb

@@ -77,6 +77,20 @@ module Samagotchi
           Thread.current[:samagotchi_reline_echo] = was
         end
 
+        # Run a read (on this thread) whose submitted line may echo with a
+        # line above it: +above+ is called with the echoed text at Enter, a
+        # String goes above the echo (a gap's divider before a typed
+        # prompt), nil adds nothing. Only a read drawn on a screen; a read
+        # without echo calls nothing.
+        # @param above [#call] (text) -> String or nil
+        def echo_above(above)
+          was = Thread.current[:samagotchi_reline_echo_above]
+          Thread.current[:samagotchi_reline_echo_above] = above
+          yield
+        ensure
+          Thread.current[:samagotchi_reline_echo_above] = was
+        end
+
         # @api private
         attr_writer :reading
 
@@ -228,9 +242,13 @@ module Samagotchi
       def clear_screen(key) = ed_clear_screen(key)
 
       # The typed lines, or the echo's text after the prompt (#echo_as).
+      # A line above them when the read has one (#echo_above).
       def seam_echo_lines
-        text = Thread.current[:samagotchi_reline_echo]&.call(@buffer_of_lines.join("\n"))
-        text ? [Reline::Unicode.strip_non_printing_start_end(prompt_list[0]) + text] : seam_final_lines
+        typed = @buffer_of_lines.join("\n")
+        text = Thread.current[:samagotchi_reline_echo]&.call(typed)
+        lines = text ? [Reline::Unicode.strip_non_printing_start_end(prompt_list[0]) + text] : seam_final_lines
+        above = Thread.current[:samagotchi_reline_echo_above]&.call(text || typed)
+        above ? [above, *lines] : lines
       end
 
       # The prompt and the text as render_finished writes them: one line per

data/lib/samagotchi/terminal_ui.rb

@@ -30,6 +30,7 @@ require_relative "terminal_ui/attached_view"
 require_relative "terminal_ui/between_turns"
 require_relative "terminal_ui/event_renderer"
 require_relative "terminal_ui/formatting"
+require_relative "terminal_ui/gap_clock"
 require_relative "terminal_ui/input_support"
 require_relative "terminal_ui/image_input"
 require_relative "terminal_ui/plain_surface"
@@ -114,7 +115,8 @@ module Samagotchi
     #   +toolkit_flags+ then)
     def initialize(prompt: nil, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, no_default_input: false, model_name: nil, memories: [], muted_memories: [], non_interactive: false, surface: nil,
                    spinner_tick_interval: AttachedView::TICK_INTERVAL, spinner_clock: nil, scratch: false, llm_context: {}, thinking: nil,
-                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], settings: nil, parent_answers: nil)
+                   appended_prompt_files: [], toolkit: nil, toolkit_flags: [], settings: nil, parent_answers: nil,
+                   now: -> { MessageTime.now })
       @scratch        = scratch
       @parent_answers = parent_answers
       @toolkit        = toolkit
@@ -190,8 +192,12 @@ module Samagotchi
       @renderer = EventRenderer.new(@view)
       # Cards, notices and a recap announced between turns, printed by the
       # main thread at the open prompt (#poll_input_with_reminder_check).
+      # The session's last activity, for the gap dividers (+now+: the wall
+      # clock, a Time).
+      @gaps = GapClock.new(now: now)
       @between_turns = BetweenTurns.new(surface: @surface, view: @view, renderer: @renderer,
-                                        turn_running: -> { @engine.turn_running? }, quiet: @non_interactive)
+                                        turn_running: -> { @engine.turn_running? }, quiet: @non_interactive,
+                                        gaps: @gaps)
       @render_event = ->(event) { handle_stream_event(event) }
       @engine = Engine.new(
         client: client,
@@ -213,7 +219,7 @@ module Samagotchi
             # When a reminder is due, queue a synthetic turn that
             # run_assist_loop checks before read_input. The synthetic turn
             # uses an empty prompt so the agent can see
-            # [SYSTEM: REMINDERS DUE] and act on them.
+            # [SYSTEM: REMINDERS DUE <local time>] and act on them.
             @engine.note_due_reminders(due_names)
           }
         }
@@ -593,7 +599,9 @@ module Samagotchi
         messages = ContextNote.with_system_head(session.messages.dup, system_message)
         banner("Resumed session: #{session.id}")
         saved = @engine.saved_recap
-        banner(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
+        banner(recap_block(saved[:text], turns_since: saved[:turns_since], at: saved[:created_at])) if saved
+        # The first prompt after a quiet gap has its divider.
+        @gaps.seed(session.messages, fallback: saved&.dig(:created_at))
       elsif @scratch
         messages = [system_message]
         banner("Scratch session: nothing is kept, it is deleted when you leave.")
@@ -721,6 +729,8 @@ module Samagotchi
     ensure
       @active_cancel_controller = nil
       @view.finish_thinking_spinner
+      # The turn's end is the last activity.
+      @gaps.touch
     end
 
     # How the REPL leaves its session once the loop ended (#run): :scratch
@@ -909,6 +919,9 @@ module Samagotchi
 
       @turn_flow.before_prompt_turn
       persist_recent_history(input)
+      # Off a live region (no echo seam) the divider comes here; after
+      # #gap_above_echo it marks none.
+      mark_activity
       begin
         # Engine#run_turn injects due reminders as a tail message, appends
         # the prompt, and renders through @renderer via on_event.
@@ -1051,6 +1064,7 @@ module Samagotchi
         sync_continue_slot(false)
         @surface.commit(QuestionSlot.continue_summary("(dropped: a reminder ran)", paint: method(:paint)))
       end
+      mark_activity
       @surface.commit(reminder_line(names))
       hint = "#{reminder_line(names)} · Ctrl-C cancels it"
       @surface.set_slot(:hints, [color_output? ? paint(hint, 90) : hint])
@@ -1147,13 +1161,34 @@ module Samagotchi
     # a question's ? prompt. +prefill+ is typed in first.
     def read_repl_line(prompt, prefill)
       queue_input_prefill(prefill) if prefill
-      return read_prompt_line(prompt) if prompt == paint("> ", 92)
+      return RelineSeam.echo_above(method(:gap_above_echo)) { read_prompt_line(prompt) } if prompt == paint("> ", 92)
 
       read = -> { with_next_input_prefill { Reline.readline(prompt, true) }&.strip }
       # A question's answer leaves only its summary line.
       prompt == paint(QUESTION_PROMPT, 33) ? RelineSeam.without_echo(&read) : read.call
     end
 
+    # Activity starts now: a gap's divider first when one passed since the
+    # last (none while a turn runs: a steer is no gap; none in a
+    # --non-interactive run, whose stdout is the answer's alone).
+    def mark_activity
+      line = @gaps.divider(quiet: @non_interactive || @engine.turn_running?)
+      @surface.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 at the idle prompt after a quiet gap.
+    # It marks the activity, so #run_input_line marks none.
+    def gap_above_echo(text)
+      return nil if @engine.turn_running? || @turn_flow.awaiting_continue?
+
+      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
+
     # Lines come from a pipe or a file (`chi -p X </dev/null`, `echo … | chi`),
     # not a terminal: no prompt is restored for a retry.
     def piped_input? = !$stdin.tty?

data/lib/samagotchi/tool_activity.rb

@@ -43,6 +43,17 @@ module Samagotchi
     # Without a "[tool]" lead (an older or hand-made output) it stays as it is.
     def saved_result_text(output) = output.to_s.sub(SAVED_LEAD, "")
 
+    # A call the guardrails denied, as its saved text reads after the
+    # "[tool]" lead (ToolRunner#denied, Guardrails::Verdict#deny_text): a
+    # rule's or hook's deny, a legacy hook veto, or the user declining (or
+    # cancelling) the approval.
+    GUARDRAIL_DENIED = /\AError: (?:(?:denied|blocked) by guardrail\b|The (?:user declined this call|approval was cancelled)\b.*? It needed approval \()/m
+
+    # Whether a saved result text (#saved_result_text) is a guardrail's
+    # deny: "blocked" as live (its activity's status), not "error", for a
+    # call with no saved tool record.
+    def guardrail_denied?(text) = text.to_s.scrub.match?(GUARDRAIL_DENIED)
+
     # @param registry [Tools::Registry, nil] the session's tools
     # @param cwd [String, nil] what a file tool's title is relative to (the
     #   worker runs in its session's working directory)

data/lib/samagotchi/turn_checkpoint.rb

@@ -7,6 +7,7 @@ require_relative "atomic_file"
 require_relative "interrupted_turn"
 require_relative "last_turn"
 require_relative "log"
+require_relative "message_time"
 require_relative "session"
 require_relative "session_inbox"
 require_relative "steer"
@@ -181,7 +182,9 @@ module Samagotchi
       @written_at = nil
       @started_at = Time.now.iso8601(3)
       messages = Array(@session.messages).dup
-      messages << { role: "user", content: prompt, **author } unless prompt.to_s.empty?
+      # Stamped by the wall clock here, a moment before the turn's own
+      # stamp (Engine's Turn#wall), which the turn's first boundary saves.
+      messages << { role: "user", content: prompt, **author, MessageTime::KEY => MessageTime.iso(MessageTime.now) } unless prompt.to_s.empty?
       @session.turn_checkpoint = { messages: messages, marker: InterruptedTurn.new(started_at: @started_at, at: @started_at, iteration: 0,
                                                                                    enqueued_id: @enqueued_id) }
     end
@@ -202,6 +205,8 @@ module Samagotchi
       return false unless conversation
 
       @boundaries += 1
+      # The merge's stamps are this copy's own; Steer.inject! stamps the
+      # live merge a moment later.
       merged = merging.empty? ? [] : Steer.merge(merging).messages
       # One level deep: the loop may edit an entry in place later (a
       # forget stub) while a save on another thread serializes this one.

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.109.0"
+  VERSION = "0.110.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -38,6 +38,7 @@ require_relative "../version"
 require_relative "../config"
 require_relative "../output_formatter"
 require_relative "../image_store"
+require_relative "../message_time"
 require_relative "../context_note"
 require_relative "../context_sources"
 require_relative "../context_providers"
@@ -2683,11 +2684,12 @@ module Samagotchi
       # a live worker's (it counts against its Engine's messages), else
       # recap.json against the session file. A stopped session gets its
       # recap without a worker being woken.
-      # @return [Hash, nil] {text:, turns_since:}
+      # @return [Hash, nil] {text:, turns_since:, created_at:} (created_at:
+      #   when it was written, UTC ISO; absent from an older recap)
       def saved_recap_for(id, session, turn_snapshot)
         if turn_snapshot
           saved = turn_snapshot["saved_recap"]
-          return saved && { text: saved["text"], turns_since: saved["turns_since"].to_i }
+          return saved && { text: saved["text"], turns_since: saved["turns_since"].to_i, created_at: saved["created_at"] }.compact
         end
 
         saved = RecapStore.read(@session_class.session_dir(id, state_dir: default_state_dir))
@@ -2695,7 +2697,7 @@ module Samagotchi
 
         messages = Array(session.messages)
         since = messages.drop(saved[:covered].to_i).count { |m| Samagotchi::Steer.turn_prompt?(m) }
-        { text: saved[:text], turns_since: since }
+        { text: saved[:text], turns_since: since, created_at: saved[:created_at] }.compact
       rescue StandardError
         nil
       end
@@ -2732,7 +2734,7 @@ module Samagotchi
           role = (m[:role] || m["role"]).to_s
           content = (m[:content] || m["content"]).to_s
           if Samagotchi::ContextNote.note?(m)
-            note = { role: "note", content: Samagotchi::ContextNote.text_of(m), label: Samagotchi::ContextNote.label_of(m) }
+            note = { role: "note", content: Samagotchi::ContextNote.text_of(m), label: Samagotchi::ContextNote.label_of(m), **time_of(m) }
             # A context wake turn's note starts that turn (Steer.turn_prompt?):
             # the page opens the turn with it and pairs it with its record.
             if Samagotchi::Steer.turn_prompt?(m)
@@ -2745,7 +2747,7 @@ module Samagotchi
           # A plugin's steer: a row of the step that answered it, which the
           # page finds by `step`.
           if Samagotchi::Steer.steer?(m)
-            filtered << { role: "steer", content: content, source: (m[:source] || m["source"]).to_s, step: steer_step(list, index) }
+            filtered << { role: "steer", content: content, source: (m[:source] || m["source"]).to_s, step: steer_step(list, index), **time_of(m) }
             next
           end
           # A turn that ended with no answer (TurnNote.empty's marker): its
@@ -2768,7 +2770,7 @@ module Samagotchi
           norm_role = "user" if norm_role == "user"
           next unless %w[user assistant].include?(norm_role)
 
-          message = { role: norm_role, content: stripped }
+          message = { role: norm_role, content: stripped, **time_of(m) }
           # Merged into the running turn (Steer::INPUT_KIND): part of it,
           # read by step +step+; a wake turn's report starts its turn
           # (Steer.turn_prompt?). Its sender (a delegate report, chi send):
@@ -2808,6 +2810,13 @@ module Samagotchi
         []
       end
 
+      # The entry's wall time (MessageTime: the page's hover and gap
+      # dividers) as {at:}, or nothing for an entry saved without one.
+      def time_of(message)
+        at = Samagotchi::MessageTime.of(message)
+        at.is_a?(String) && !at.empty? ? { at: at } : {}
+      end
+
       # A no-answer turn's marker as display items: each empty step that
       # has something to show (its thinking) as a text-less assistant step
       # (only with +parts+, as other text-less steps), then

data/lib/samagotchi/web/participant_view.rb

@@ -108,7 +108,7 @@ module Samagotchi
       def turn_started(event, viewer)
         origin = TurnOrigin.of(field(event, :origin))
         author = field(event, :author) || origin.author
-        out = { "type" => "turn_started", **id_fields(event) }
+        out = { "type" => "turn_started", **id_fields(event), **time_field(event) }
         out.merge!(author_fields(author, field(event, :author_name), viewer))
         prompt = field(event, :prompt)
         if field(event, :continue)
@@ -164,8 +164,8 @@ module Samagotchi
       #   analytics records' +automatic+, and the running one's): their
       #   prompt is shown as an automatic turn, without its text
       # @return [Array<Hash>] {role: "user", content, turn_id, author,
-      #   author_name, mine, automatic, images} and {role: "assistant",
-      #   content, tools: [{tool, path}]}; no notes, steers, automatic
+      #   author_name, mine, automatic, images, at} and {role: "assistant",
+      #   content, tools: [{tool, path}], at}; no notes, steers, automatic
       #   input or empty-answer markers. html is added by the caller, from
       #   this (redacted) content.
       def messages(shown, viewer, automatic: [])
@@ -194,7 +194,7 @@ module Samagotchi
         merged = field(message, :merged)
         return nil unless turn_id || merged
 
-        out = { "role" => "user" }
+        out = { "role" => "user", **time_field(message) }
         if turn_id && automatic.include?(turn_id.to_s)
           out.merge!("content" => "", "automatic" => true, "turn_id" => turn_id.to_s)
           return out
@@ -215,7 +215,7 @@ module Samagotchi
         content = field(message, :content).to_s
         return nil if content.strip.empty? && rows.empty?
 
-        out = { "role" => "assistant", "content" => content }
+        out = { "role" => "assistant", "content" => content, **time_field(message) }
         out["tools"] = rows unless rows.empty?
         out
       end
@@ -287,6 +287,13 @@ module Samagotchi
         out
       end
 
+      # When it happened (MessageTime's stamp, a turn's start): the page's
+      # hover and gap dividers. A wall time only, nothing of what was done.
+      def time_field(item)
+        at = field(item, :at)
+        at.is_a?(String) && !at.empty? ? { "at" => at } : {}
+      end
+
       def id_fields(event)
         out = seq(event)
         turn_id = field(event, :turn_id)

data/lib/samagotchi/web/public/app.js

@@ -46,6 +46,7 @@ import { createCardsPlace } from "./cards_place.js";
 import { createStageView } from "./stage_view.js";
 import { createWorkingSet, groupItems } from "./working_set_view.js";
 import { turnGroups } from "./timing.js";
+import { createGapClock, lastActivity } from "./time_gaps.js";
 import { createMarkdownPlace } from "./markdown_place.js";
 import { openerFill, openTitle, restoredComposer } from "./chains.js";
 import { createTaskStopper } from "./task_stop.js";
@@ -371,8 +372,11 @@ const bubbles = createBubbles({
 });
 const {
   removeHintIfEmpty, appendChunk, addEndBubble, makeUserBubble, bubbleById, applyPromptOps, showRecap, markRecapStale,
-  showGuardrailWarning, showSteers, showHookNotice, addCommandBubble, commandBubble, addNoteBubble,
+  showGuardrailWarning, showSteers, showHookNotice, addCommandBubble, commandBubble, addNoteBubble, addTimeGap,
 } = bubbles;
+// The open session's last activity, for the live gap dividers
+// (time_gaps.js): renderHistory seeds it, the stream moves it.
+const gapClock = createGapClock();
 // The plugin cards and a snapshot's notices in the history (cards_place.js).
 const cards = createCardsPlace({
   historyEl,
@@ -947,7 +951,7 @@ function renderSessionView(data, { kept = [] } = {}) {
   if (!loadWarned("plugins")) showGuardrailWarning(data.plugin_warning, "plugins");
   // The recap saved with the session (also a stopped one's), else a live
   // worker's from before saved_recap existed.
-  if (data.saved_recap) showRecap(data.saved_recap.text, data.saved_recap.turns_since);
+  if (data.saved_recap) showRecap(data.saved_recap.text, data.saved_recap.turns_since, data.saved_recap.created_at || null);
   else showRecap(data.recap);
   // A live worker's last cards and between-turns notices, where they
   // arrived; the running turn's go into its step once it is drawn.
@@ -1004,12 +1008,15 @@ function seedWorkingSet(data) {
 }
 
 function renderHistory(items) {
+  gapClock.seed(null);
   if (!items.length) {
     historyEl.replaceChildren(hintEl("No output yet. Send a message."));
     return;
   }
   if (typeof items[0] === "object" && items[0].role) {
     historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsTemplate(selected, images), workingSet: !!workingSet }));
+    // The live dividers count from the history's last activity.
+    gapClock.seed(lastActivity(turnGroups(items, current.timing), items));
     linkTextRefs();
   } else {
     historyEl.replaceChildren(...items.map((c) => elementOf(outputBubbleTemplate(c))));
@@ -1416,7 +1423,8 @@ const streamHandlers = createStreamHandlers({
   setUsedMemories, onInitEvent, findInTurnRoots, applyFinalMarkdown,
   // bubbles.js
   applyPromptOps, showSteers, markRecapStale, appendChunk, makeUserBubble, addEndBubble, commandBubble,
-  addCommandBubble, addNoteBubble, showRecap, showGuardrailWarning, showHookNotice,
+  addCommandBubble, addNoteBubble, showRecap, showGuardrailWarning, showHookNotice, addTimeGap,
+  gapClock,
   // cards_place.js
   upsertCard, refreshCardBodies,
   syncModelPick: startPage.commandRan,

data/lib/samagotchi/web/public/bubbles.js

@@ -4,7 +4,7 @@
 // notices, plugins' steers, command and note bubbles. The markup is lit
 // (turn_html.js elementOf); createBubbles puts them in the history.
 import { html, nothing } from "./vendor/lit-html.js";
-import { normalize, recapLabel, recapPlace } from "./format.js";
+import { fullTime, normalize, recapLabel, recapPlace } from "./format.js";
 import { BADGES, elementOf, noteBubbleTemplate, stateBadgeTemplate, steerRowTemplate, userBubbleTemplate } from "./turn_html.js";
 import { thumbsTemplate } from "./images.js";
 import { appendAboveLiveTiming, STOPPED_LINE_CLASS } from "./timing.js";
@@ -12,6 +12,7 @@ import { keepFollowing } from "./scroll.js";
 import { linkedLine } from "./notice_links.js";
 import { hookNoticeLabel, isReportClient, promptOps } from "./turn_events.js";
 import { drawCommandBubble } from "./commands.js";
+import { TIME_GAP_CLASS, timeGapEl } from "./time_gaps.js";
 
 export function removeQueuedBubble(bubble) {
   if (!bubble) return;
@@ -49,8 +50,11 @@ export function endBubbleTemplate(text, { stopped = false } = {}) {
 }
 
 // The idle recap, open; a stale one (+turnsSince+ > 0) says it is earlier.
-export function recapTemplate(text, turnsSince = 0) {
-  return html`<details class=${turnsSince > 0 ? "bubble recap stale" : "bubble recap"} open><summary>${recapLabel(turnsSince)}</summary><div class="recap-body">${text}</div></details>`;
+// +createdAt+: when it was written (its label's time, kept for the stale
+// label as data-created-at).
+export function recapTemplate(text, turnsSince = 0, createdAt = null, now = Date.now()) {
+  const created = typeof createdAt === "string" && createdAt ? createdAt : nothing;
+  return html`<details class=${turnsSince > 0 ? "bubble recap stale" : "bubble recap"} data-created-at=${created} open><summary>${recapLabel(turnsSince, false, createdAt, now)}</summary><div class="recap-body">${text}</div></details>`;
 }
 
 // A guardrail hook or rule file that failed to load (once per worker), or
@@ -228,14 +232,16 @@ export function createBubbles({
   // the end of the history. A turn starting leaves it in place, marked
   // earlier; only a new recap replaces it.
 
-  function showRecap(text, turnsSince = 0) {
+  function showRecap(text, turnsSince = 0, createdAt = null) {
     if (!text) return;
     removeRecap();
-    const details = elementOf(recapTemplate(text, turnsSince));
+    const details = elementOf(recapTemplate(text, turnsSince, createdAt));
     // A stale one sits where it was written, above the turns it doesn't cover.
     // Never in the stage: a recap is between turns.
     turnDom.settleFold?.();
-    const before = recapPlace(turnPromptBubbles(historyEl), turnsSince);
+    const prompt = recapPlace(turnPromptBubbles(historyEl), turnsSince);
+    // Above that turn's gap divider too: the recap was written before the quiet stretch ended.
+    const before = prompt?.previousElementSibling?.matches(`.${TIME_GAP_CLASS}`) ? prompt.previousElementSibling : prompt;
     keepFollowing(historyEl, () => (before ? historyEl.insertBefore(details, before) : appendAboveLiveTiming(historyEl, details, liveTurn.timing.el)));
   }
 
@@ -244,7 +250,7 @@ export function createBubbles({
     historyEl.querySelectorAll(".bubble.recap:not(.stale)").forEach((el) => {
       el.classList.add("stale");
       const summary = el.querySelector("summary");
-      if (summary) summary.textContent = recapLabel(0, true);
+      if (summary) summary.textContent = recapLabel(0, true, el.dataset.createdAt || null);
     });
   }
 
@@ -282,6 +288,9 @@ export function createBubbles({
     const id = selected();
     if (id) div.dataset.keptFor = id;
     drawCommandBubble(div, view);
+    // When it happened (a reminder's at): the hover, as a reload's bubbles.
+    const when = fullTime(view.at);
+    if (when) div.title = when;
     placeFollowing(div);
   }
 
@@ -295,8 +304,21 @@ export function createBubbles({
     placeFollowing(elementOf(noteBubbleTemplate(note)));
   }
 
+  // A quiet stretch passed (time_gaps.js): its divider above +before+ (a
+  // turn's prompt bubble, wherever it sits), else at the end.
+  function addTimeGap(text, { before = null } = {}) {
+    if (!text) return null;
+    const el = timeGapEl(text);
+    if (before?.parentNode) {
+      keepFollowing(historyEl, () => before.parentNode.insertBefore(el, before));
+      return el;
+    }
+    return placeFollowing(el);
+  }
+
   return {
     removeHintIfEmpty, placeFollowing, appendChunk, addEndBubble, makeUserBubble, bubbleById, applyPromptOps, showRecap,
     markRecapStale, showGuardrailWarning, showSteers, showHookNotice, addCommandBubble, commandBubble, addNoteBubble,
+    addTimeGap,
   };
 }