samagotchi 0.109.0 → 0.111.0

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)

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.