samagotchi 0.125.0 → 0.127.0

data/lib/samagotchi/children_status.rb

@@ -86,11 +86,16 @@ module Samagotchi
                 state: state_of(session, row, reply), waiting: row[:waiting], live: !!row[:live],
                 delegate: session.delegate?, cwd: session.working_directory, branch: GitHead.branch(session.working_directory),
                 last_reply: reply && first_line(session.id, reply, state_dir: state_dir),
-                last_reply_at: reply && reply_time(reply), reported: !reply.nil? && cursor.reply_file == reply,
+                last_reply_at: reply && reply_time(reply), reported: !reply.nil? && reported?(session, cursor, reply),
                 updated_at: session.updated_at, archived: !!row[:archived])
     end
     private_class_method :child
 
+    # A reply the parent was given; a Verify fresh child's always counts
+    # (its verdict goes to the parent's card, never a report).
+    def reported?(session, cursor, reply) = !session.verify_fresh.nil? || cursor.reply_file == reply
+    private_class_method :reported?
+
     def state_of(session, row, reply)
       return "waiting" if row[:waiting]
       return "running" if Tools::Delegate.running?(row)

data/lib/samagotchi/engine.rb

@@ -15,6 +15,8 @@ require_relative "steer"
 require_relative "turn_note"
 require_relative "turn_endings"
 require_relative "turn_origin"
+require_relative "verify_anchor"
+require_relative "verdict"
 require_relative "model_profile"
 require_relative "effective_model"
 require_relative "session_setting"
@@ -901,10 +903,12 @@ module Samagotchi
 
     # Event types #announce accepts: facts about the session's input queue,
     # a failed turn's prompt handed back and the continue offer, which live
-    # UIs need in the event log, emitted outside any turn's stream.
+    # UIs need in the event log, emitted outside any turn's stream; a
+    # Verify fresh child's verdict landing on its card (:verdict_recorded).
     ANNOUNCEABLE_EVENTS = %i[turn_enqueued turn_dequeued input_merged prompt_restored continue_offered continue_resolved
                              command_queued command_ran context_added card hook_notice guardrail_warning
-                             plugin_init_started plugin_init_finished working_set_updated participants_changed].freeze
+                             plugin_init_started plugin_init_finished working_set_updated participants_changed
+                             verdict_recorded].freeze
 
     # Put a transport-level event into the ordered event log. Unlike turn
     # events it reaches only persistent observers (no turn sink, no memory
@@ -1589,7 +1593,10 @@ module Samagotchi
       seconds = turn.elapsed
       synchronize_events do
         kept, event = yield(seconds)
+        stamp_verify_anchor(kept, turn)
         replace_session_messages(turn.session, kept) if kept
+        verdict = record_verdict(turn, outcome)
+        event[:verdict] = verdict if verdict
         emit_working_set(turn.on_event, turn.session, turn.session.messages)
         turn.session.status = Session::STATUS_IDLE
         record_last_turn(turn.session, outcome, seconds, turn.origin, event, limit: exhausted ? turn.limit : nil)
@@ -1602,6 +1609,31 @@ module Samagotchi
     end
     private :end_turn
 
+    def stamp_verify_anchor(messages, turn)
+      return unless turn.verify && messages.is_a?(Array)
+
+      opening = messages.reverse.find do |message|
+        (message[:role] || message["role"]).to_s == "user" &&
+          (message[:turn_id] || message["turn_id"]).to_s == turn.id
+      end
+      opening[:verify] = turn.verify.to_h if opening
+    end
+    private :stamp_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 save_quietly(session)
       session.save(state_dir: session_state_dir)
     rescue StandardError => e
@@ -2011,7 +2043,7 @@ module Samagotchi
     # +wall+: the wall time it started (MessageTime.now, once): the
     # :turn_started event's at and its user message's (and reminders') stamp.
     Turn = Struct.new(:session, :prompt, :continue, :on_event, :controller, :origin, :started_at, :messages, :ended,
-                      :settings, :id, :limit, :resumed, :resume_from, :wall) do
+                      :settings, :id, :limit, :resumed, :resume_from, :wall, :verify) do
       def resumed? = resumed ? true : false
 
       # The turn's boundary events carry the origin only when it names a
@@ -2083,9 +2115,9 @@ module Samagotchi
     # re-raises; a provider error adds error_kind:, retryable:, host: and a
     # one-line summary:.
     def run_turn(session, prompt, on_event: nil, max_iterations: nil, cancel_controller: nil, max_tool_output_chars: nil, pending_input: nil, continue: false,
-                 origin: TurnOrigin::NONE, images: [], id: nil, resumed: false, resume_from: nil)
+                 origin: TurnOrigin::NONE, images: [], id: nil, resumed: false, resume_from: nil, verify: nil)
       turn = begin_turn(session, prompt, on_event: on_event, cancel_controller: cancel_controller, origin: origin,
-                                         continue: continue, id: id)
+                                         continue: continue, id: id, verify: verify)
       if continue
         turn.resumed = resumed
         turn.resume_from = resume_from
@@ -2133,8 +2165,11 @@ module Samagotchi
     # The turn's state before anything can fail it: the session running,
     # the turn flag, its cancel controller and sink. The cross-thread state
     # is set here and cleared in #release_turn only.
-    def begin_turn(session, prompt, on_event:, cancel_controller:, origin:, continue:, id: nil)
+    def begin_turn(session, prompt, on_event:, cancel_controller:, origin:, continue:, id: nil, verify: nil)
       origin = TurnOrigin.of(origin)
+      # A participant's Verify fresh child: every turn is theirs (their
+      # author, boundary and cap), whoever started it.
+      origin = session.verify_fresh.origin_for(origin) if session.respond_to?(:verify_fresh) && session.verify_fresh
       # Track the active session for recap and status snapshot.
       @session = session
       # status is turn state: running now, idle again before the turn's end
@@ -2157,7 +2192,7 @@ module Samagotchi
 
       Turn.new(session: session, prompt: continue ? nil : prompt, continue: continue, on_event: on_event,
                controller: effective_controller, origin: origin, started_at: Process.clock_gettime(Process::CLOCK_MONOTONIC),
-               id: id || SecureRandom.uuid, wall: MessageTime.now)
+               id: id || SecureRandom.uuid, wall: MessageTime.now, verify: VerifyAnchor.from(verify))
     end
     private :begin_turn
 
@@ -2360,6 +2395,7 @@ module Samagotchi
       unless turn.continue
         user_message = { role: "user", content: turn.prompt, turn_id: turn.id, **author_fields(turn.origin.author),
                          **participant_mode_fields(turn.origin.author), MessageTime::KEY => turn.at }
+        user_message[:verify] = turn.verify.to_h if turn.verify
         user_message[:images] = image_refs unless image_refs.empty?
         turn.messages << user_message
         session.last_prompt = turn.prompt

data/lib/samagotchi/guardrail_wiring.rb

@@ -109,9 +109,18 @@ module Samagotchi
       @git = Guardrails::GitInfo.new
       author = turn_author
       @turn_entry = author && @participant.call(author)
-      @turn_mode = author && ParticipantMode.for_turn(@session_lookup.call, @turn_entry)
+      @turn_mode = author && participant_turn_mode(@session_lookup.call, @turn_entry)
     end
 
+    # A participant's turn's mode: in a Verify fresh child the one saved
+    # on it at spawn (VerifyFreshOrigin#turn_mode: :review unless saved
+    # :pair), never looked up again; elsewhere ParticipantMode.for_turn.
+    def participant_turn_mode(session, entry)
+      fresh = session.respond_to?(:verify_fresh) && session.verify_fresh
+      fresh ? fresh.turn_mode : ParticipantMode.for_turn(session, entry)
+    end
+    private :participant_turn_mode
+
     # The running participant turn's mode (ParticipantMode.for_turn: :pair
     # only in a working session for a participant invited to act), decided
     # at its start; nil for the owner's turns. The boundary in #checks, the

data/lib/samagotchi/llm/chat_loop.rb

@@ -447,6 +447,7 @@ module Samagotchi
           message[:images] = entry[:images] if entry[:images].is_a?(Array) && !entry[:images].empty?
           message[:turn_id] = entry[:turn_id] if entry[:turn_id]
           message[:turn_start] = true if entry[:turn_start] == true
+          message[:verify] = entry[:verify] if entry[:verify].is_a?(Hash)
           message[:thinking] = entry[:thinking] if entry[:thinking].is_a?(String) && !entry[:thinking].empty?
           message[:anthropic_content] = entry[:anthropic_content] if entry[:anthropic_content].is_a?(Array)
           ToolResponse::SAVED_KEYS.each { |key| message[key] = entry[key] if entry[key] }

data/lib/samagotchi/session.rb

@@ -20,6 +20,10 @@ require_relative "project_scope"
 require_relative "guardrails/parent_levels"
 
 module Samagotchi
+  # Loaded on first use (a Verify fresh child): keeps the bundle test kit's
+  # load budget (spec/samagotchi/testing/sandbox_spec.rb).
+  autoload :VerifyFreshOrigin, File.expand_path("verify_fresh_origin", __dir__)
+
   # archive_store requires this file.
   autoload :ArchiveStore, File.expand_path("archive_store", __dir__)
 
@@ -134,6 +138,14 @@ module Samagotchi
       @last_turn = LastTurn.from_file(value)
     end
 
+    # Verdict cards recorded by completed Verify turns, in append order.
+    # A missing field stays missing until the first verdict is recorded.
+    def verdicts = @verdicts || []
+
+    def verdicts=(values)
+      @verdicts = values.nil? ? nil : Array(values)
+    end
+
     # The mark of a turn a worker checkpointed and never finished
     # (InterruptedTurn), as loaded; the next worker settles it and sets it
     # to nil. While a turn runs, #turn_checkpoint's marker is saved instead.
@@ -280,6 +292,20 @@ module Samagotchi
     # Whether this is a review session (chi review, the web's Start review).
     def review? = !@review.nil?
 
+    # A Verify fresh child's requester, rules and claim (VerifyFreshOrigin),
+    # nil for any other session. Set once, at spawn (VerifyFresh.start).
+    attr_reader :verify_fresh
+
+    # @param value [VerifyFreshOrigin, Hash, nil] the session file's form too
+    def verify_fresh=(value)
+      @verify_fresh = value.nil? ? nil : VerifyFreshOrigin.of(value)
+    end
+
+    # The session whose participants.json names this session's
+    # participants: a Verify fresh child's parent (its requester's grant is
+    # the parent's), else the session itself.
+    def participants_source_id = @verify_fresh && @parent_id ? @parent_id : @id
+
     # How many tool outputs its history holds: its tool messages
     # (tool_response, a chat loop's tool; a native step's one message holds
     # every call's output and counts once).
@@ -333,7 +359,7 @@ module Samagotchi
                    last_turn: nil, model_typed: nil, delegate: false, llm_context: nil, prompt_notes: [],
                    continues: nil, thinking: nil, reasoning_history: nil, appended_prompt_files: [],
                    toolkit: nil, toolkit_origin: "chosen", settings: nil, interrupted_turn: nil, parent_answers: nil, title: nil,
-                   working_set_pins: [], review: nil)
+                   working_set_pins: [], review: nil, verdicts: nil, verify_fresh: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
@@ -370,6 +396,8 @@ module Samagotchi
       self.parent_answers = parent_answers
       self.working_set_pins = working_set_pins
       self.review = review
+      self.verdicts = verdicts
+      self.verify_fresh = verify_fresh
       self.interrupted_turn = interrupted_turn
       @turn_checkpoint = nil
       @archived = false
@@ -539,6 +567,7 @@ module Samagotchi
       "parent_id" => nil,
       "scratch" => false,
       "last_turn" => nil,
+      "verdicts" => nil,
       "delegate" => false,
       "llm_context" => nil,
       "continues" => nil,
@@ -553,12 +582,13 @@ module Samagotchi
       "parent_answers" => nil,
       "working_set_pins" => [],
       "review" => nil,
-      "first_turn_id" => nil
+      "first_turn_id" => nil,
+      "verify_fresh" => nil
     }.freeze
 
     # FIELDS a session file has only when set: a session without them saves
     # as it did before they existed.
-    OPTIONAL_FIELDS = %w[review first_turn_id].freeze
+    OPTIONAL_FIELDS = %w[review first_turn_id verdicts verify_fresh].freeze
 
     # A session from a parsed session file. +messages+ false leaves the
     # conversation out (the lists' lightweight summaries).
@@ -712,6 +742,13 @@ module Samagotchi
                 when "last_turn" then @last_turn&.to_file
                 when "working_set_pins" then @working_set_pins.map(&:to_file)
                 when "review" then @review&.to_file
+                when "verify_fresh" then @verify_fresh&.to_file
+                when "verdicts"
+                  @verdicts&.map do |record|
+                    scrub_utf8(record.to_h do |key, entry|
+                      [key.to_s, entry.is_a?(Hash) ? stringify_message_keys(entry) : entry]
+                    end)
+                  end
                 when "used_memory_names", "preloaded_memory_names", "muted_memory_names", "appended_prompt_files"
                   Array(instance_variable_get(:"@#{key}"))
                 else instance_variable_get(:"@#{key}")

data/lib/samagotchi/session_inbox.rb

@@ -12,6 +12,10 @@ require_relative "steer"
 require_relative "turn_origin"
 
 module Samagotchi
+  # Loaded on first use (a Verify turn's input): keeps the bundle test kit's
+  # load budget (spec/samagotchi/testing/sandbox_spec.rb).
+  autoload :VerifyAnchor, File.expand_path("verify_anchor", __dir__)
+
   # A session directory's file inbox and outbox (see SessionManager for the
   # layout): input/ holds one JSON file per queued turn, notes/ the context
   # notes a worker adds between turns, output/ one text file per reply,
@@ -53,7 +57,7 @@ module Samagotchi
     # @param now [Time] the time the file is named by (a spec's clock)
     # @return [String, false] the input file's path, or false
     def self.write_input(session_dir, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [],
-                         delivery: nil, author: nil, now: Time.now)
+                         delivery: nil, author: nil, verify: nil, now: Time.now)
       images = Array(images)
       input_dir = File.join(session_dir, INPUT_DIR)
       FileUtils.mkdir_p(input_dir)
@@ -63,7 +67,7 @@ module Samagotchi
                  "no_interrupt" => (no_interrupt ? true : nil),
                  "delivery" => (Delivery.queue?(delivery) ? Delivery::QUEUE : nil),
                  "images" => (images.empty? ? nil : images.map { |image| image.transform_keys(&:to_s) }),
-                 "author" => author }.compact
+                 "author" => author, "verify" => VerifyAnchor.from(verify)&.to_file }.compact
       AtomicFile.write(path, JSON.generate(record))
       path
     rescue StandardError
@@ -228,9 +232,9 @@ module Samagotchi
     # (+no_interrupt+, --no-interrupt), its +images+ ({file:, name:} refs),
     # and its +delivery+ ("queue" or nil; a file without the key is one an
     # older chi wrote, so nil).
-    Input = Data.define(:prompt, :origin, :no_interrupt, :images, :delivery) do
-      def initialize(prompt:, origin: nil, no_interrupt: false, images: [], delivery: nil)
-        super(prompt:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:)
+    Input = Data.define(:prompt, :origin, :no_interrupt, :images, :delivery, :verify) do
+      def initialize(prompt:, origin: nil, no_interrupt: false, images: [], delivery: nil, verify: nil)
+        super(prompt:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:, verify: verify && VerifyAnchor.from(verify))
       end
     end
     # A file that doesn't parse, or isn't a JSON object: no prompt.
@@ -246,7 +250,7 @@ module Samagotchi
       origin = TurnOrigin.from(data.slice("client_id", "enqueued_id", "author"))
       images = Array(data["images"]).select { |image| image.is_a?(Hash) }.map { |image| image.transform_keys(&:to_sym) }
       Input.new(prompt: data["prompt"].to_s, origin: origin, no_interrupt: data["no_interrupt"] == true,
-                images: images, delivery: Delivery.queue?(data["delivery"]) ? Delivery::QUEUE : nil)
+                images: images, delivery: Delivery.queue?(data["delivery"]) ? Delivery::QUEUE : nil, verify: data["verify"])
     rescue JSON::ParserError
       UNREADABLE_INPUT
     end
@@ -278,9 +282,11 @@ module Samagotchi
       true
     end
 
-    # A parsed input file's #waits_for_turn_end?.
+    # A parsed input file's #waits_for_turn_end?. A Verify turn waits too:
+    # merged into a running turn as a steer, its anchor would be lost.
     def self.turn_end_data?(data)
-      Array(data["images"]).any? || Delivery.queue?(data["delivery"]) || Steer.participant_author?(data["author"])
+      Array(data["images"]).any? || Delivery.queue?(data["delivery"]) || Steer.participant_author?(data["author"]) ||
+        data["verify"].is_a?(Hash)
     end
 
     # How the unclaimed input file carrying +enqueued_id+ waits: :turn_end

data/lib/samagotchi/session_manager.rb

@@ -164,6 +164,8 @@ module Samagotchi
     #   turn sees it
     # @param review [SessionReview, nil] a review session's (ReviewStart; a
     #   continue keeps its previous link's)
+    # @param verify_fresh [VerifyFreshOrigin, nil] a Verify fresh child's
+    #   requester, rules and claim (VerifyFresh.start)
     # @param before_spawn [#call, nil] (session) runs once the session and
     #   its note are saved, before its worker spawns
     # @return [Session] with #seed_images_dropped: refs whose file was gone,
@@ -171,7 +173,7 @@ module Samagotchi
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
                            preview: nil, title: nil, delegate: false, setup: SessionSetup.new, continues: nil, note: nil,
-                           note_source: "chi", before_spawn: nil, review: nil)
+                           note_source: "chi", before_spawn: nil, review: nil, verify_fresh: nil)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
       # alias is retargeted), with the name as typed beside it. A wrong host
@@ -198,6 +200,8 @@ module Samagotchi
       )
       session.toolkit = Toolkit.configured(delegate: delegate) if session.toolkit.nil?
       session.toolkit_origin = setup.toolkit_origin || "default"
+      # Saved before the worker starts: its first turn is already the requester's.
+      session.verify_fresh = verify_fresh
       session.model_warning = model_warning
       # With no prompt there is no first turn to run (an attaching UI sends
       # the prompts), so the session starts idle.
@@ -1310,10 +1314,10 @@ module Samagotchi
     #   session's images/
     # @return [String, false] the input file's path, or false.
     def self.write_turn_input(session_id, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, state_dir: nil,
-                              images: [], delivery: nil, author: nil)
+                              images: [], delivery: nil, author: nil, verify: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       SessionInbox.write_input(session_dir, prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
-                                            no_interrupt: no_interrupt, images: images, delivery: delivery, author: author)
+                                            no_interrupt: no_interrupt, images: images, delivery: delivery, author: author, verify: verify)
     end
 
     # How long a turn waits for the Bridge of a worker a resume just spawned.
@@ -1395,7 +1399,8 @@ module Samagotchi
     # @raise [OwnedByTUI] a chi REPL owns the session
     # @raise [ArgumentError] no such session
     def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], delivery: nil, no_interrupt: false,
-                          author: nil, pending_limit: nil, state_dir: nil, manager: self, bridge: nil)
+                          author: nil, pending_limit: nil, verify: nil, state_dir: nil, manager: self, bridge: nil)
+      verify = VerifyAnchor.from(verify)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       bridge ||= lambda do
         link = WorkerLink.await(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT)
@@ -1417,6 +1422,7 @@ module Samagotchi
           options[:no_interrupt] = true if no_interrupt
           options[:author] = author if author
           options[:pending_limit] = pending_limit if author && pending_limit
+          options[:verify] = verify if verify
           reply = client.post_turn(**options)
           ack = reply.json
           return DeliverResult.new(status: :accepted, via: :bridge, ack: ack) if reply.status == 202 && ack.is_a?(Hash)
@@ -1454,6 +1460,7 @@ module Samagotchi
       input[:delivery] = delivery unless Delivery.next_step?(delivery)
       input[:no_interrupt] = true if no_interrupt
       input[:author] = author if author
+      input[:verify] = verify if verify
       path = participant_queue_lock(session_dir, author && pending_limit) do
         # No worker: the participant's waiting files are all their turns,
         # counted and written under one lock (the Bridge counts under its).

data/lib/samagotchi/session_participants.rb

@@ -22,8 +22,10 @@ module Samagotchi
     end
 
     # Reads +session+'s sidecar again.
+    # A Verify fresh child reads its parent's (Session#participants_source_id):
+    # its requester's grant is there.
     def refresh!(session)
-      @session_id = session&.id
+      @session_id = source_id(session)
       @entries = read
       self
     end
@@ -44,7 +46,7 @@ module Samagotchi
     def entry_for(author, session: nil)
       return nil unless Steer.participant_author?(author)
 
-      refresh!(session) if session && session.id != @session_id
+      refresh!(session) if session && source_id(session) != @session_id
       id = Steer.participant_id(author)
       @entries.find { |e| e.id == id } || (@entries = read).find { |e| e.id == id }
     end
@@ -52,16 +54,35 @@ module Samagotchi
     # The system prompt's participants line while anyone is in it (#active?
     # as of the last #refresh!): ParticipantMode::PAIR when +session+ is a
     # working session and an active participant was invited to act, else
-    # ParticipantMode::REVIEW; nil with nobody active.
+    # ParticipantMode::REVIEW; nil with nobody active. A Verify fresh
+    # child reads its parent's sidecar but has one participant at most, its
+    # requester: their saved mode while their grant is active, nil for the
+    # owner's child (no participant ever writes in it).
     def prompt_mode(session)
       active = @entries.select { |entry| entry.active?(@clock.call) }
       return nil if active.empty?
 
+      fresh = session.respond_to?(:verify_fresh) && session.verify_fresh
+      return fresh_prompt_mode(fresh, active) if fresh
+
       active.any? { |entry| ParticipantMode.for_turn(session, entry) == ParticipantMode::PAIR } ? ParticipantMode::PAIR : ParticipantMode::REVIEW
     end
 
     private
 
+    def fresh_prompt_mode(fresh, active)
+      return nil unless fresh.participant?
+
+      id = Steer.participant_id(fresh.author)
+      active.any? { |entry| entry.id == id } ? fresh.turn_mode : nil
+    end
+
+    def source_id(session)
+      return nil unless session
+
+      session.respond_to?(:participants_source_id) ? session.participants_source_id : session.id
+    end
+
     def read
       return [] if @session_id.to_s.empty?
 

data/lib/samagotchi/verdict.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A parsed verdict line from a Verify turn's final answer.
+  Verdict = Data.define(:verdict, :reason) do
+    LINE = /\AVerdict:\s*(confirmed|refuted|unclear)\b\s*(?:—|–|-)\s*(.+?)\s*\z/i
+    MARKDOWN = /(?:\*\*|__|`)/
+
+    def self.parse(text)
+      line = text.to_s.lines.reverse_each.find { |candidate| !candidate.strip.empty? }
+      return unless line
+
+      normalized = line.strip.gsub(MARKDOWN, "")
+      match = LINE.match(normalized)
+      return unless match
+
+      new(verdict: match[1].downcase, reason: match[2].strip)
+    end
+  end
+end

data/lib/samagotchi/verify_anchor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A claim selected in an earlier turn, carried only by a Verify turn.
+  VerifyAnchor = Data.define(:turn_id, :quote) do
+    UUID = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+    QUOTE_MAX = 200
+
+    def self.from(value)
+      return value if value.is_a?(self)
+      return nil unless value.is_a?(Hash)
+
+      fields = value.to_h { |key, entry| [key.to_s, entry] }
+      return nil unless fields.keys.sort == %w[quote turn_id]
+
+      turn_id = fields["turn_id"]
+      quote = fields["quote"]
+      return nil unless turn_id.is_a?(String) && UUID.match?(turn_id)
+      return nil unless quote.is_a?(String) && quote.length.between?(1, QUOTE_MAX) && !quote.strip.empty?
+
+      new(turn_id:, quote:)
+    end
+
+    def to_h = { turn_id:, quote: }
+
+    def to_file = { "turn_id" => turn_id, "quote" => quote }
+  end
+end