samagotchi 0.60.0 → 0.61.0

data/lib/samagotchi/answer_refs.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "log"
+require_relative "ref"
+
+module Samagotchi
+  # One ref on the answer: the text it stands for (+match+, what the page
+  # pairs it with) and the Ref itself. +to_h+ is the stored and sent shape,
+  # {match:, kind:, target:, label:, actions:}.
+  AnswerRef = Data.define(:match, :ref) do
+    # @raise [ArgumentError] an empty match, one over MAX_MATCH, or a ref
+    #   that isn't a Ref
+    def initialize(match:, ref:)
+      match = match.to_s.strip
+      raise ArgumentError, "a ref needs a match (the text it stands for)" if match.empty?
+      raise ArgumentError, "a ref's match is at most #{AnswerRef::MAX_MATCH} characters" if match.length > AnswerRef::MAX_MATCH
+      raise ArgumentError, "not a Ref" unless ref.is_a?(Ref)
+
+      super
+    end
+
+    def to_h = { match: match, **ref.to_h }
+  end
+
+  class AnswerRef
+    MAX_MATCH = 500
+
+    # A hook's {match:, kind:, target:, label:, actions:}, or a stored
+    # entry (String or Symbol keys, nested ones too). A file ref's relative
+    # path is resolved against +cwd+, so the stored path is absolute; with
+    # no +cwd+ it is refused. An absolute path stays as given.
+    # @raise [ArgumentError] anything invalid
+    def self.from(value, cwd: nil)
+      raise ArgumentError, "a ref is a Hash {match:, kind:, target:, label:, actions:}" unless value.is_a?(Hash)
+
+      value = value.transform_keys(&:to_sym)
+      ref = Ref.new(kind: value[:kind], target: value[:target], label: value[:label], actions: value[:actions] || [])
+      new(match: value[:match], ref: absolute(ref, cwd))
+    end
+
+    def self.absolute(ref, cwd)
+      return ref unless ref.kind == Ref::FILE
+
+      path = ref.target[:path]
+      return ref if File.absolute_path?(path)
+      raise ArgumentError, "relative path, no session folder" if cwd.to_s.empty?
+
+      # absolute_path, not expand_path: a leading ~ is a name, never a home.
+      Ref.new(kind: ref.kind, target: ref.target.merge(path: File.absolute_path(path, cwd.to_s)), label: ref.label,
+              actions: ref.actions)
+    end
+    private_class_method :absolute
+  end
+
+  # The refs after_turn hooks attach to a turn's answer (event[:refs]),
+  # kept as `display_refs` on the answer's model message next to its
+  # `display` (AnswerDisplay). Display only, like `display`: the model
+  # never sees them (AnswerDisplay::DISPLAY_ONLY), and a UI pairs each with
+  # its +match+ in the shown answer (or drops it).
+  #
+  # The target is AnswerDisplay's: the stored conversation's last message
+  # when it is the model's. The list starts from the refs it already has
+  # (re-validated), so a later hook run never loses them.
+  class AnswerRefs
+    KEY = :display_refs
+    MAX_REFS = 200
+    # The list's JSON; a ref that would cross it is refused.
+    MAX_BYTES = 256 * 1024
+
+    # Stored refs (+raw+, as read from session.json or a snapshot), each
+    # rebuilt and checked again, the caps applied; what isn't valid any
+    # more is dropped. Never raises: a reload must show the conversation.
+    # A relative file path is dropped (there is no folder to resolve it).
+    # @return [Array<Hash>] the refs to send ({match:, kind:, target:, …})
+    def self.for_display(raw)
+      return [] if raw.nil?
+
+      kept = new([{ role: "model", KEY => raw }], cwd: nil).to_a
+      dropped = raw.is_a?(Array) ? raw.length - kept.length : 1
+      Log.debug(:web, "display_refs_dropped", count: dropped) if dropped.positive?
+      kept
+    rescue StandardError
+      []
+    end
+
+    # @return [Hash, nil] the message event[:refs] adds to
+    attr_reader :target
+
+    # @param messages [Array<Hash>] the conversation the turn stored
+    # @param cwd [String, nil] the session's folder, for relative file paths
+    def initialize(messages, cwd:)
+      last = Array(messages).last
+      @target = last if last.is_a?(Hash) && (last[:role] || last["role"]).to_s == "model"
+      @cwd = cwd
+      @refs = []
+      @seen = {}
+      @bytes = 2 # the list's []
+      @added = false
+      @closed = false
+      @rejections = Hash.new(0)
+      seed(@target) if @target
+    end
+
+    # True when a hook added a ref the answer didn't have.
+    def added? = @added
+
+    def count = @refs.length
+
+    # @return [Array<Hash>] the refs as stored ({match:, kind:, target:, …})
+    def to_a = @refs.dup
+
+    # The list is stored (Engine#store_answer_display): a later call (a
+    # plugin that kept event[:refs]) would be lost, so it returns nil.
+    def close! = @closed = true
+
+    def closed? = @closed
+
+    # event[:refs]: call it with the ref's keywords,
+    # +call(match:, kind:, target:, label: nil, actions: [])+.
+    # @param event [Hash] the after_turn event (for its :hook label)
+    # The hook's label is read at call time: one adder serves every hook of
+    # the fire, and the registry sets event[:hook] before each.
+    # @return [Proc] true when the ref is kept (or was already there), false
+    #   when it is refused (logged, named by event[:hook]), nil when the
+    #   turn has no answer or the list was already stored (#close!)
+    def adder(event)
+      lambda do |*args, **ref|
+        next nil unless @target
+        next late(event[:hook]) if @closed
+        next reject(event[:hook], "takes keywords (match:, kind:, target:, label:, actions:)") unless args.empty?
+
+        add(ref, event[:hook])
+      end
+    end
+
+    private
+
+    KEYS = %i[match kind target label actions].freeze
+    REASON_VALUES = /\(.*?\)|\[.*?\]|".*?"|\d+/
+    private_constant :KEYS, :REASON_VALUES
+
+    def seed(target)
+      raw = target[KEY] || target[KEY.to_s]
+      raw.each { |entry| keep(entry) } if raw.is_a?(Array)
+    end
+
+    def add(value, hook)
+      unknown = value.keys - KEYS
+      return reject(hook, "has unknown keys #{unknown.map(&:to_s).inspect}") unless unknown.empty?
+
+      entry = AnswerRef.from(value, cwd: @cwd).to_h
+      return true if @seen.key?(entry)
+      return over_cap(hook, "#{MAX_REFS} refs") if @refs.length >= MAX_REFS
+
+      size = JSON.generate(entry).bytesize + (@refs.empty? ? 0 : 1)
+      return over_cap(hook, "#{MAX_BYTES / 1024} KiB") if @bytes + size > MAX_BYTES
+
+      push(entry, size)
+      @added = true
+    rescue StandardError => e
+      reject(hook, e.message)
+    end
+
+    # A stored entry back in the list, checked again (a relative path is
+    # dropped: it was stored absolute). Duplicates and what is over the
+    # caps go quietly.
+    # @return [Boolean] kept
+    def keep(raw)
+      entry = AnswerRef.from(raw, cwd: nil).to_h
+      return false if @seen.key?(entry) || @refs.length >= MAX_REFS
+
+      size = JSON.generate(entry).bytesize + (@refs.empty? ? 0 : 1)
+      return false if @bytes + size > MAX_BYTES
+
+      push(entry, size)
+      true
+    rescue StandardError
+      false
+    end
+
+    def push(entry, size)
+      @refs << entry
+      @seen[entry] = true
+      @bytes += size
+    end
+
+    def over_cap(hook, cap) = reject(hook, "over the cap (#{cap})")
+
+    def late(hook)
+      Log.debug(:hooks, "refs_late", hook: hook.to_s)
+      nil
+    end
+
+    # Each reason is said once per hook per answer (a warn and its echo);
+    # the same again goes to debug with its count, so a hook looping over
+    # bad refs can't flood the terminal. The reason's values (a kind, a
+    # key list, a cap) don't make it a new one.
+    def reject(hook, why)
+      count = @rejections[[hook.to_s, why.gsub(REASON_VALUES, "")]] += 1
+      if count == 1
+        Log.warn(:hooks, "refs_rejected", echo: "[samagotchi:hooks] #{hook}: ref #{why}; dropped",
+                                          hook: hook.to_s, reason: why)
+      else
+        Log.debug(:hooks, "refs_rejected", hook: hook.to_s, reason: why, count: count)
+      end
+      false
+    end
+  end
+end

data/lib/samagotchi/bridge/card_store.rb

@@ -45,7 +45,11 @@ module Samagotchi
     # its own), and a question still open when the worker went waits for no
     # one: neither is saved or seeded. Same caps as in memory. An entry from
     # an earlier worker lists with +earlier+: true (an attached TUI's resync
-    # onto a new worker doesn't print those again).
+    # onto a new worker doesn't print those again). An earlier card shown
+    # during a turn (+in_turn+) comes back without its actions: they belong
+    # to a turn no worker runs any more (check-in's Nudge would steer the
+    # new worker's turn). A card shown between turns (github-pr's offer,
+    # btw, coordinator) keeps its buttons.
     class CardStore
       CAPACITY = 20
       NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry steer_cut].freeze
@@ -137,6 +141,7 @@ module Samagotchi
           next unless entry.is_a?(Hash) && entry[:type].is_a?(String) && entry[:turns].is_a?(Integer)
 
           entry = entry.merge(type: entry[:type].to_sym, earlier: true)
+          entry = entry.merge(actions: []) if entry[:type] == :card && entry[:in_turn] && entry.key?(:actions)
           entry unless entry[:type] == :guardrail_warning || open_question?(entry)
         end
         settle_during(after_turn: false)

data/lib/samagotchi/bundles/check-in/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: check-in
-version: 0.2.3
+version: 0.2.4
 scope: system
 description: "Checks on a long turn: after N tool calls with no answer, a card asks the user (Nudge / Keep going / Stop), or the model is nudged to say what it has found"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:821aea2821df12f278db9a94f8150244e67bf9453735d19a5abe9d94253eefa6
+  sha256: sha256:42fe075c664d256ecb8623b76a25d5c389e42c0534a41c56fe17b073d521e095
 requires_chi: ">= 0.3.0"

data/lib/samagotchi/bundles/check-in/plugin.rb

@@ -11,6 +11,10 @@
 # final answer is dropped: the card's Nudge then says so at the turn's end
 # (after_turn's messages have no steer with its text).
 #
+# One nudge per check-in: a second Nudge (a repeat click, a stale card's
+# button, a typed /checkin nudge) for the same check-in only says it was
+# already nudged; before the turn's first check-in, one nudge in all.
+#
 # The count is per turn: before_turn resets it (and closes a card left open
 # by a turn that failed or was interrupted, where after_turn doesn't fire);
 # steering merged mid-turn does not. The /checkin commands are anytime ones
@@ -76,6 +80,8 @@ class Plugin
     @card_id = nil  # this turn's card, once shown
     @card_open = false
     @nudge = nil    # the card's Nudge this turn: { text:, count: }
+    @checked_in = nil # the count at this turn's latest check-in
+    @nudged_for = nil # the check-in (its count, :none before one) nudged
   end
 
   def before_turn(ctx)
@@ -97,6 +103,7 @@ class Plugin
       next nil unless @enabled && @count >= @next_at
 
       @next_at = @count + @every
+      @checked_in = @count
       [@count, @mode]
     end
     check_in(ctx, *due) if due
@@ -107,7 +114,10 @@ class Plugin
     when "nudge"
       text = message(count)
       if ctx.steer(text)
-        @mutex.synchronize { @nudge = { text: text, count: count } }
+        @mutex.synchronize do
+          @nudge = { text: text, count: count }
+          @nudged_for = count
+        end
         ctx.notify("nudged the model after #{count} tool calls")
       end
     when "notify"
@@ -232,10 +242,24 @@ class Plugin
     "check-in after #{n} tool calls, then every #{n}, for this session"
   end
 
+  # At most one nudge per check-in; the slot is taken before the steer (two
+  # clicks race on the anytime command's threads) and given back when no
+  # turn took it.
   def nudge(ctx)
-    count = calls
+    count, key, earlier = @mutex.synchronize do
+      key = @checked_in || :none
+      next [nil, nil, @nudge&.dig(:count) || @count] if @nudged_for == key
+
+      @nudged_for = key
+      [@count, key, nil]
+    end
+    return "check-in: already nudged at #{earlier} tool calls" if earlier
+
     text = message(count)
-    return "check-in: no turn running" unless ctx.steer(text)
+    unless ctx.steer(text)
+      @mutex.synchronize { @nudged_for = nil if @nudged_for == key }
+      return "check-in: no turn running"
+    end
 
     @mutex.synchronize { @nudge = { text: text, count: count } }
     close_card(ctx, "Nudged the model at #{count} tool calls.")

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.60.0
+version: 0.61.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/engine.rb

@@ -64,6 +64,7 @@ require_relative "sampling_settings"
 require_relative "thinking"
 require_relative "reasoning_history"
 require_relative "answer_display"
+require_relative "answer_refs"
 require_relative "edit_preview"
 require_relative "question_desk"
 require_relative "child_reports"
@@ -1478,19 +1479,31 @@ module Samagotchi
     private :save_quietly
 
     # Keep what the after_turn hooks presented as the answer's `display`
-    # and tell the observers (:answer_display), after the turn_completed
-    # they already had: the web re-reads the answer then. A turn_completed
+    # and the refs they attached as its `display_refs` (AnswerRefs, one
+    # replace for both), and tell the observers (:answer_display, the
+    # display or nil, and how many refs), after the turn_completed they
+    # already had: the web re-reads the answer then. A turn_completed
     # with display_pending (after_turn hooks were about to run) always gets
     # one, `display: nil` when nothing was presented, so the web holds the
     # answer's pop until then and never swaps it after. Terminals are not
     # sinks of it; they printed the answer already. The session is saved by
     # the caller, as after every turn.
-    def store_answer_display(session, display, pending: false)
+    def store_answer_display(session, display, refs, pending: false)
       synchronize_events do
+        # A plugin that kept event[:refs] and calls it later gets nil: the
+        # list is stored now (and the turn is over on every path).
+        refs.close!
         messages = Array(session.messages)
-        if display.changed? && messages.last.equal?(display.target)
-          replace_session_messages(session, messages[0...-1] + [display.target.merge(AnswerDisplay::KEY => display.text)])
-          @session_observer.notify({ type: :answer_display, display: display.text })
+        changed = display.changed? && messages.last.equal?(display.target)
+        added = refs.added? && messages.last.equal?(refs.target)
+        if changed || added
+          merged = messages.last.dup
+          merged[AnswerDisplay::KEY] = display.text if changed
+          merged[AnswerRefs::KEY] = refs.to_a if added
+          replace_session_messages(session, messages[0...-1] + [merged])
+          event = { type: :answer_display, display: changed ? display.text : nil }
+          event[:refs] = refs.count if added
+          @session_observer.notify(event)
         elsif pending
           @session_observer.notify({ type: :answer_display, display: nil })
         end
@@ -2228,15 +2241,18 @@ module Samagotchi
 
       # Fire :after_turn hook (an answer or a Stop; an Interrupt or a failure
       # ends the turn in #run_turn without it), with a read-only
-      # copy of the conversation the turn stored, and event[:present] for
-      # a display version of the answer (AnswerDisplay).
+      # copy of the conversation the turn stored, event[:present] for
+      # a display version of the answer (AnswerDisplay) and event[:refs]
+      # for refs on it (AnswerRefs).
       session = turn.session
       display = AnswerDisplay.new(session.messages)
+      refs = AnswerRefs.new(session.messages, cwd: session.working_directory)
       after_turn = { type: :after_turn, status: canceled ? "canceled" : "completed",
                      messages: hook_messages(session.messages) }
       after_turn[:present] = display.presenter(after_turn)
+      after_turn[:refs] = refs.adder(after_turn)
       @hooks.fire(:after_turn, after_turn)
-      store_answer_display(session, display, pending: display_pending)
+      store_answer_display(session, display, refs, pending: display_pending)
 
       # Fire :session_end after the turn (turn-level lifecycle), as :after_turn
       @hooks.fire(:session_end, { type: :session_end, session_id: session.id })
@@ -2547,6 +2563,19 @@ module Samagotchi
       clone_messages(@session&.messages)
     end
 
+    # The running turn's conversation as its loop builds it (both loops
+    # register it on the kernel's llm_context_turn): the same array the loop
+    # appends to, not a copy, so read it on the turn's thread (the pending
+    # input drain, at an iteration boundary: TurnCheckpoint). nil when no
+    # turn runs (llm_context_turn is never cleared, and still holds the
+    # last turn's then).
+    # @return [Array<Hash>, nil]
+    def live_conversation
+      return nil unless turn_running? && @kernel.respond_to?(:llm_context_turn)
+
+      @kernel.llm_context_turn&.conversation
+    end
+
     # Append messages to the current session's conversation.
     # @param messages [Array<Hash>]
     # @return [Array<Hash>] the session's messages

data/lib/samagotchi/hooks/registry.rb

@@ -253,9 +253,11 @@ module Samagotchi
       #   event[:steer].call(text) -> true when the text was queued for the
       #     running turn's next boundary (its own user message, source: the
       #     hook's bundle); from after_turn / session_end false
-      # and after_turn's fire site adds one more (AnswerDisplay):
+      # and after_turn's fire site adds two more (AnswerDisplay, AnswerRefs):
       #   event[:present].call { |text| new_text } -> the answer's display
       #     text after the call (chained in hook order), nil without an answer
+      #   event[:refs].call(match:, kind:, target:, label: nil, actions: [])
+      #     -> true (kept), false (refused, logged), nil without an answer
       #
       # @param name [Symbol] the hook name to fire
       # @param event [Hash] the event payload (may be mutated by hooks)

data/lib/samagotchi/interrupted_turn.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # The mark of a turn a worker checkpointed and never finished
+  # (Session#interrupted_turn, saved as session.json's "interrupted_turn"):
+  # TurnCheckpoint writes it with the turn's messages so far while the turn
+  # runs; the turn's end saves without it; the next worker to start finds it
+  # and settles the turn (Worker#settle_interrupted_turn).
+  #
+  # id: the turn's id (nil when unknown); started_at / at: iso8601, when the
+  # turn began and when this checkpoint was taken; iteration: the loop
+  # boundaries it had passed (Integer).
+  InterruptedTurn = Data.define(:id, :started_at, :at, :iteration) do
+    def initialize(id: nil, started_at: nil, at: nil, iteration: nil) = super
+
+    # A saved record (string or symbol keys), an InterruptedTurn as it is;
+    # nil for anything else.
+    # @return [InterruptedTurn, nil]
+    def self.from_file(raw)
+      return raw if raw.is_a?(InterruptedTurn)
+      return nil unless raw.is_a?(Hash)
+
+      new(**members.to_h { |m| [m, raw.key?(m.to_s) ? raw[m.to_s] : raw[m]] })
+    end
+
+    # @return [Hash{String => Object}] string keys, unset fields left out
+    def to_file = to_h.compact.transform_keys(&:to_s)
+
+    # Seconds from the turn's start to this checkpoint (nil when unknown).
+    # @return [Float, nil]
+    def seconds
+      return nil unless started_at && at
+
+      (Time.iso8601(at) - Time.iso8601(started_at)).clamp(0, Float::INFINITY)
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/samagotchi/kernel_loop.rb

@@ -1003,11 +1003,13 @@ module Samagotchi
     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] }.compact
+          { role: m[:role], content: m[:content].to_s, display: m[:display], display_refs: m[:display_refs] }.compact
         elsif m[:role] == "model"
-          # `display` rides along so the stored conversation keeps it; the
-          # prompt formatter never reads it (AnswerDisplay).
-          { role: m[:role], content: strip_thought_blocks(m[:content].to_s), display: m[:display] }.compact
+          # `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
         else
           m.dup
         end

data/lib/samagotchi/llm/chat_loop.rb

@@ -11,6 +11,7 @@ require_relative "native_tool_normalizer"
 require_relative "stream_drops"
 require_relative "../kernel_loop"
 require_relative "../answer_display"
+require_relative "../answer_refs"
 require_relative "../cut_policy"
 require_relative "../context_status"
 require_relative "../context_window"
@@ -302,8 +303,9 @@ module Samagotchi
       # refs of a user message or a tool result, a prompt's turn_id (Engine,
       # never sent) and a wake turn's report's turn_start (Steer, never sent), and a plugin tool result's tool_params and tool_labels
       # (the live row's params line and label, never sent back), an
-      # edit/write result's tool_diffs (never sent), and an empty-answer
-      # note's marker (TurnNote.empty, never sent).
+      # edit/write result's tool_diffs (never sent), an empty-answer
+      # note's marker (TurnNote.empty, never sent), and an answer's display
+      # and display_refs (AnswerDisplay, AnswerRefs; never sent).
       def plain(conversation)
         conversation.map do |entry|
           content = entry[:content].is_a?(Array) ? entry[:content] : entry[:content].to_s
@@ -319,6 +321,7 @@ module Samagotchi
           marker = TurnNote.empty_answer(entry)
           message[TurnNote::EMPTY_ANSWER] = marker if marker
           message[AnswerDisplay::KEY] = entry[AnswerDisplay::KEY] if entry[AnswerDisplay::KEY]
+          message[AnswerRefs::KEY] = entry[AnswerRefs::KEY] if entry[AnswerRefs::KEY]
           ContextNote::KEYS.each { |key| message[key] = entry[key] if entry.key?(key) }
           message
         end

data/lib/samagotchi/log_subscriber.rb

@@ -152,10 +152,13 @@ module Samagotchi
       log(level, :hook_notice, hook: event[:hook], fallback_for: event[:fallback_for], msg: event[:text].to_s[0, 300])
     end
 
-    # after_turn hooks presented the answer (AnswerDisplay): its size only
-    # (none for the display: nil that says nothing was presented).
+    # after_turn hooks presented the answer (AnswerDisplay) or attached refs
+    # to it (AnswerRefs): the display's size and the refs' count only (none
+    # for the display: nil that says nothing was presented).
     def on_answer_display(event)
-      log(:info, :answer_display, chars: event[:display].to_s.length) if event[:display]
+      return unless event[:display] || event[:refs]
+
+      log(:info, :answer_display, chars: event[:display]&.length, refs: event[:refs])
     end
 
     # A card shown to the user (Engine#show_card): whose, which, and its

data/lib/samagotchi/ref.rb

@@ -10,14 +10,17 @@ module Samagotchi
   # (refs.js httpUrl): the page opens it as is, so a javascript:, data: or
   # editor URL never gets there.
   RefAction = Data.define(:id, :label, :url) do
-    # @raise [ArgumentError] an empty id or label, or a URL that isn't an
-    #   http(s) one with a host, at most MAX_URL characters
+    # @raise [ArgumentError] an empty id or label, one over its cap
+    #   (MAX_ID, MAX_LABEL), or a URL that isn't an http(s) one with a host,
+    #   at most MAX_URL characters
     def initialize(id:, label:, url:)
       id = id.to_s.strip
       label = label.to_s.strip
       url = url.to_s.strip
       raise ArgumentError, "a ref action needs an id" if id.empty?
       raise ArgumentError, "a ref action needs a label" if label.empty?
+      raise ArgumentError, "a ref action's id is at most #{RefAction::MAX_ID} characters" if id.length > RefAction::MAX_ID
+      raise ArgumentError, "a ref action's label is at most #{RefAction::MAX_LABEL} characters" if label.length > RefAction::MAX_LABEL
       raise ArgumentError, "a ref action's url must be http(s) with a host, at most #{RefAction::MAX_URL} characters" unless RefAction.http_url?(url)
 
       super
@@ -26,13 +29,17 @@ module Samagotchi
 
   class RefAction
     MAX_URL = 2_000
+    MAX_ID = 64
+    MAX_LABEL = 100
 
-    # @return [Boolean] +url+ is an http or https URL with a host
+    # @return [Boolean] +url+ is an http or https URL with a host and no
+    #   userinfo (a "https://github.com@evil.example/" shows one host and
+    #   opens another, and a token in it would be copied around)
     def self.http_url?(url)
       return false if url.length > MAX_URL
 
       uri = URI.parse(url)
-      uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+      uri.is_a?(URI::HTTP) && !uri.host.to_s.empty? && uri.userinfo.nil?
     rescue URI::InvalidURIError
       false
     end
@@ -61,13 +68,17 @@ module Samagotchi
   # rows' own ref; this is the one a plugin gives.
   Ref = Data.define(:kind, :target, :label, :actions) do
     # @raise [ArgumentError] a kind that isn't a short lowercase word, a
-    #   target without its kind's key, a non-list of actions or a bad action
+    #   target without its kind's key, a non-list of actions, a bad action,
+    #   or a value over its cap (MAX_LABEL, MAX_ACTIONS, MAX_ID, MAX_PATH)
     def initialize(kind:, target:, label: nil, actions: [])
       kind = kind.to_s
       raise ArgumentError, "a ref's kind is a short lowercase word (#{kind.inspect})" unless Ref::KIND.match?(kind)
       raise ArgumentError, "a ref's actions are a list" unless actions.nil? || actions.is_a?(Array)
+      raise ArgumentError, "a ref has at most #{Ref::MAX_ACTIONS} actions" if Array(actions).length > Ref::MAX_ACTIONS
 
       label = label.to_s.strip
+      raise ArgumentError, "a ref's label is at most #{Ref::MAX_LABEL} characters" if label.length > Ref::MAX_LABEL
+
       super(kind: kind, target: Ref.target_for(kind, target), label: label.empty? ? nil : label,
             actions: Array(actions).map { |action| RefAction.from(action) }.freeze)
     end
@@ -81,6 +92,11 @@ module Samagotchi
     KIND = /\A[a-z][a-z0-9_-]{0,31}\z/
     # FileRef::KIND, not required here (it loads the file tools).
     FILE = "file"
+    # Caps, so a plugin can't bloat session.json or the page.
+    MAX_LABEL = 200
+    MAX_ACTIONS = 8
+    MAX_ID = 200
+    MAX_PATH = 4_096
 
     # A plugin's {kind:, target:, label:, actions:} (String or Symbol keys).
     # @raise [ArgumentError] as +new+
@@ -97,19 +113,20 @@ module Samagotchi
       raise ArgumentError, "a ref's target is a Hash" unless raw.is_a?(Hash)
 
       raw = raw.transform_keys(&:to_sym)
-      kind == FILE ? file_target(raw) : { id: required(raw[:id], :id) }.freeze
+      kind == FILE ? file_target(raw) : { id: required(raw[:id], :id, MAX_ID) }.freeze
     end
 
     def self.file_target(raw)
       line = positive(raw[:line])
       end_line = line && positive(raw[:end_line])
-      { path: required(raw[:path], :path), line: line, end_line: end_line && end_line > line ? end_line : nil }.compact.freeze
+      { path: required(raw[:path], :path, MAX_PATH), line: line, end_line: end_line && end_line > line ? end_line : nil }.compact.freeze
     end
     private_class_method :file_target
 
-    def self.required(value, key)
+    def self.required(value, key, max)
       value = value.to_s.strip
       raise ArgumentError, "a ref's target needs #{key}" if value.empty?
+      raise ArgumentError, "a ref's target #{key} is at most #{max} characters" if value.length > max
 
       value
     end

data/lib/samagotchi/reply_wait.rb

@@ -106,10 +106,14 @@ module Samagotchi
 
         if session.status == Session::STATUS_RUNNING
           seen_running = true
-        elsif seen_running || turn_ended_since?(session, baseline)
+        elsif (seen_running && !baseline&.key?(:last_turn)) || turn_ended_since?(session, baseline)
           # It ran and is idle again with no new reply: canceled, failed or
           # empty. Before it was ever seen running, idle means a
-          # file-delivered message its worker has not picked up yet.
+          # file-delivered message its worker has not picked up yet. With
+          # the baseline's last_turn only a turn that ended since counts:
+          # a session left running by a worker that died goes idle when the
+          # next worker settles that turn (TurnCheckpoint.settle), before
+          # the sent message's turn runs.
           # The worker writes the reply before its idle save, so the read
           # above has it; one more look costs nothing should that change.
           return reply_past(id, state_dir: state_dir, cursor: cursor)&.tap { |r| r.session = session } ||