samagotchi 0.154.1 → 0.156.0

data/lib/samagotchi/engine/turn_helpers.rb

@@ -5,8 +5,9 @@ module Samagotchi
     # What a turn's steps use before and around the model: its settings,
     # images and vision, the model ref and resumed run start it generates
     # with, the used memories it publishes, and the turn-end warm-up of the
-    # next one. Writes @next_turn_waiting; reads @model_settings, @kernel,
-    # @prompt_warmup, @thinking_notices, @turn_state.
+    # next one (TurnStages::Warmup, built here). Writes @next_turn_waiting;
+    # reads @model_settings, @kernel, @prompt_warmup, @thinking_notices,
+    # @turn_state, @reminder_queue, @turn_warmup.
     module TurnHelpersPart
       # The turn's settings for the kernel (LLM::TurnSettings): vision,
       # sampling and thinking, the thinking resolved before the hooks run.
@@ -34,44 +35,20 @@ module Samagotchi
       # warm-up then. nil: neither.
       attr_accessor :next_turn_waiting
 
-      # After a completed turn, prefill the next turn's prompt up to its user
-      # message while the user reads (PromptWarmup, cache.warmup). Only on a
-      # local llama.cpp host on the native loop, and not when the next turn's
-      # start differs anyway or starts at once: a reminder due, a continue
-      # offer (the turn ran out of steps), a carried steer or queued input.
-      # Never fails the turn.
-      def warm_up_next_turn(turn, result)
-        return if result.canceled? || result.resumable?
-
-        model = effective_model
-        client = model.client
-        return unless warmup_target?(model, client)
-        return if reminders_due? || @turn_state.carried_steers? || @next_turn_waiting&.call
-
-        messages = ContextNote.with_system_head(turn.session.messages.dup, { role: "system", content: system_prompt(model) })
-        # Under the next turn's strategy (a /model switch may have changed it);
-        # the last turn's when it can't be resolved.
-        prompt, images = @kernel.warmup_prompt(messages, llm_context: @model_settings.turn_llm_context || @kernel.turn_settings&.llm_context)
-        return unless prompt
-
-        started = @prompt_warmup.start(client: client, prompt: prompt, model: @kernel.turn_settings.model_name,
-                                       slot: @kernel.last_slot, images: images)
-        @kernel.warmed_up! if started
-      rescue StandardError => e
-        Log.warn(:model, "warmup_skipped", error: e.class.name, msg: e.message.to_s[0, 200])
-      end
-      private :warm_up_next_turn
-
-      # Never a paid or remote host (cache.warmup auto means local only), nor
-      # the chat loop (Splash keeps its own cache; llama.cpp's chat path is
-      # not measured), nor a client that can't warm up (a spec's stub).
-      def warmup_target?(model, client)
-        return false if model.chat? || model.entry.remote?
-        return false unless client.respond_to?(:warm_up)
-
-        PromptWarmup.enabled?
+      # The turn-end warm-up's stage (TurnStages::Warmup).
+      attr_reader :turn_warmup
+      private :turn_warmup
+
+      # The stage over the kernel and the Engine's PromptWarmup (built in
+      # #initialize, once the kernel and the reminder queue are). Its one
+      # callable is the system prompt, built late (side effects); the
+      # host's probe goes with each call (#next_turn_waiting, set after).
+      def build_turn_warmup
+        TurnStages::Warmup.new(prompt_warmup: @prompt_warmup, kernel: @kernel, turn_state: @turn_state,
+                               model_settings: @model_settings, reminder_queue: @reminder_queue,
+                               system_prompt: ->(model) { system_prompt(model) })
       end
-      private :warmup_target?
+      private :build_turn_warmup
 
       # The ref (host:model, as asked) a turn's generations ran on: the model
       # #generate resolved, after the before_turn hooks (which may switch it).

data/lib/samagotchi/engine/verify.rb

@@ -2,152 +2,16 @@
 
 module Samagotchi
   class Engine
-    # Verify and Revise anchors at a turn's end: the opening's stamp, a Revise
-    # turn's draft checked, a Verify turn's quote checked against its source
-    # session and its verdict recorded. No ivars of its own: it reads the turn,
-    # and the sessions it loads through Engine methods.
+    # Verify and Revise anchors (TurnStages::VerifyAnchors): #begin_turn
+    # checks a Verify turn's claim, #end_turn's event step stamps the opening
+    # and records the verdict. Reads @verify_anchors.
     module VerifyPart
-      # The turn's anchors, stamped on its opening message (the prompt, or a
-      # wake turn's note) in the messages it keeps: display metadata, never
-      # in the prompt (LLM::ChatLoop#plain keeps them, no wire sends them).
-      # A Verify turn's claim however it ended; a Revise turn's draft only
-      # once it completed with an answer (#revision_target). Returns the
-      # stamped ReviseAnchor (the end event's revises), or nil.
-      def stamp_opening(messages, turn, outcome)
-        return unless messages.is_a?(Array)
+      private
 
-        revises = revision_target(messages, turn, outcome)
-        fields = { verify: turn.verify&.to_h, revises: revises&.to_h }.compact
-        return if fields.empty?
+      # The anchors' stage (TurnStages::VerifyAnchors).
+      attr_reader :verify_anchors
 
-        opening = messages.reverse.find do |message|
-          Steer.turn_prompt?(message) && (message[:turn_id] || message["turn_id"]).to_s == turn.id
-        end
-        return unless opening
-
-        opening.merge!(fields)
-        revises
-      end
-      private :stamp_opening
-
-      # The turn a Revise turn revised (D6: "this turn revised that one"):
-      # only a completed turn with an answer (AnswerTail) has revised
-      # anything. A draft no prompt in the messages carries is no target (a
-      # stale page, a rolled-back turn); one a stamped turn already revised
-      # is re-targeted to its stack's top, the newest version, which the
-      # person meant ("this draft").
-      def revision_target(messages, turn, outcome)
-        return unless turn.revises && outcome == "completed"
-
-        slice = AnswerTail.turn_slice(messages, turn.id)
-        return unless slice&.any? { |message| AnswerTail.answer?(message) }
-
-        target = turn.revises.turn_id
-        seen = [turn.id]
-        until seen.include?(target)
-          return reject_revise_anchor(turn.revises, :turn_missing) unless AnswerTail.turn_slice(messages, target)
-
-          seen << target
-          newer = messages.reverse.find do |message|
-            Steer.turn_prompt?(message) && ReviseAnchor.from(message[:revises] || message["revises"])&.turn_id == target
-          end
-          return ReviseAnchor.new(turn_id: target) unless newer
-
-          target = (newer[:turn_id] || newer["turn_id"]).to_s
-        end
-        reject_revise_anchor(turn.revises, :cycle)
-      end
-      private :revision_target
-
-      def reject_revise_anchor(anchor, reason)
-        Log.warn(:turn, "revise_anchor_rejected", turn_id: anchor.turn_id, reason:)
-        nil
-      end
-      private :reject_revise_anchor
-
-      def verified_anchor(session, anchor)
-        return unless anchor
-
-        source = verify_anchor_source_session(session, anchor)
-        return unless source
-
-        turn = AnswerTail.turn_slice(Array(source.messages), anchor.turn_id)
-        return reject_verify_anchor(anchor, :turn_missing) unless turn
-
-        reply = turn.reverse.find { |message| AnswerTail.answer?(message) }
-        return reject_verify_anchor(anchor, :reply_missing) unless reply
-
-        quote_text = verify_comparison_text(anchor.quote)
-        quoted = !quote_text.empty? && verify_quote_in?(quote_text, (reply[:content] || reply["content"]).to_s, source)
-        return reject_verify_anchor(anchor, :quote_missing) unless quoted
-
-        anchor
-      end
-      private :verified_anchor
-
-      # Whether +quote_text+ is in +answer+ as the model wrote it, or as the
-      # pages show it: a page quotes its own text, which reads the session's
-      # folder relative, the home folder as ~ and a secret shape as
-      # [redacted] (a participant's page gets it so, Redact;
-      # the owner's page rewrites its quote the same way, claim_link.js
-      # normalizeClaim, so claim links match both pages). +source+ is the
-      # session whose folder that is.
-      def verify_quote_in?(quote_text, answer, source)
-        return true if verify_comparison_text(answer).include?(quote_text)
-
-        viewer = Redact::Viewer.new(cwd: source.working_directory)
-        verify_comparison_text(Redact.text(answer, viewer)).include?(quote_text)
-      end
-      private :verify_quote_in?
-
-      def verify_anchor_source_session(session, anchor)
-        return session unless session.verify_fresh
-
-        fresh = session.verify_fresh
-        return reject_verify_anchor(anchor, :fresh_anchor_mismatch) unless fresh.anchor == anchor
-        return reject_verify_anchor(anchor, :fresh_parent_missing) unless session.parent_id
-
-        Session.load(session.parent_id, state_dir: session_state_dir)
-      rescue ArgumentError, SystemCallError, IOError => e
-        Log.warn(:turn, "verify_anchor_rejected", turn_id: anchor.turn_id, reason: :source_session_unavailable,
-                                                   error: e.class.name)
-        nil
-      end
-      private :verify_anchor_source_session
-
-      def verify_comparison_text(text)
-        OutputFormatter.strip_markup(text)
-                      .gsub(/!\[([^\]]*)\]\([^)]+\)/, '\1')
-                      .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1')
-                      .gsub(/^[ \t]*(?:\#{1,6}[ \t]+|>[ \t]?|[-+*][ \t]+|\d+[.)][ \t]+)/, "")
-                      .gsub(/(\*\*|__|~~|`+)(.+?)\1/m, '\2')
-                      .gsub(/(?<!\w)\*(\S(?:.*?\S)?)\*(?!\w)/m, '\1')
-                      .gsub(/(?<!\w)_(\S(?:.*?\S)?)_(?!\w)/m, '\1')
-                      .tr("|", " ") # a table row's cells; the page copies them without the pipes
-                      .gsub(/\s+/, " ")
-                      .strip
-      end
-      private :verify_comparison_text
-
-      def reject_verify_anchor(anchor, reason)
-        Log.warn(:turn, "verify_anchor_rejected", turn_id: anchor.turn_id, reason:)
-        nil
-      end
-      private :reject_verify_anchor
-
-      def record_verdict(turn, outcome)
-        return unless outcome == "completed" && turn.verify
-
-        answer = AnswerTail.find(turn.session.messages, turn_id: turn.id)
-        parsed = Verdict.parse(answer && (answer[:content] || answer["content"]))
-        return unless parsed
-
-        record = { anchor: turn.verify.to_h, verdict: parsed.verdict, reason: parsed.reason,
-                   by: turn.origin.author, check_turn_id: turn.id, at: Time.now.iso8601(3) }
-        turn.session.verdicts = turn.session.verdicts + [record]
-        record
-      end
-      private :record_verdict
+      def build_verify_anchors = TurnStages::VerifyAnchors.new
     end
   end
 end