samagotchi 0.124.0 → 0.126.0

data/lib/samagotchi/web/push/notifier.rb

@@ -13,7 +13,8 @@ module Samagotchi
       # the summaries the page's trackAttention keeps (seeded by the
       # subscribe's snapshot, so what was open before never pushes), turns
       # each new attention (Attention.for: a question, an approval, a
-      # step-limit continue, a card with actions, a failed or done turn)
+      # step-limit continue, a card with actions, a failed or done turn, a
+      # recorded Verify verdict)
       # into a show, and hands it to its own sender thread through a Queue;
       # one answered anywhere (Attention.closed_keys) only cancels its
       # show's hold.
@@ -43,7 +44,7 @@ module Samagotchi
         HOLD = 3.0
         # Waiting kinds: kept 12 h for an offline phone, delivered at once.
         SHOW_TTL = 12 * 3600
-        # A failed or done turn: stale soon, no need to wake the phone.
+        # A failed, done or verdict turn: stale soon, no need to wake the phone.
         EVENT_TTL = 600
         # A newly available chi is useful for a day while the phone is away.
         UPDATE_TTL = 24 * 3600
@@ -280,7 +281,7 @@ module Samagotchi
           retries.each { |again| send_retry(again, open) if still_due?(again.show, open) }
         end
 
-        # A waiting show while its key is open; a failed or done turn's as
+        # A waiting show while its key is open; a failed, done or verdict turn's as
         # is (nothing to answer).
         def still_due?(show, open) = !Attention.waiting?(show.attention.reason) || open.include?(show.attention.key)
 

data/lib/samagotchi/web/session_control.rb

@@ -196,9 +196,11 @@ module Samagotchi
 
         # no_interrupt: an attached TUI's --no-interrupt (chi --remote --attach).
         # author: the principal's (nil for the owner), never the body's.
+        verify = VerifyAnchor.from(body["verify"])
         result = SessionManager.deliver_turn(id, prompt: prompt.to_s, client_id: client_id, images: images,
                                                  delivery: delivery, no_interrupt: body["no_interrupt"] == true,
                                                  author: principal(req).author,
+                                                 verify: verify,
                                                  state_dir: @state_dir, manager: @manager,
                                                  bridge: -> { live_bridge_client(id) })
         case result.status

data/lib/samagotchi/web/session_summary.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "../session"
+require_relative "../steer"
+require_relative "../participants"
+require_relative "../verify_fresh"
 require_relative "../recap_store"
 require_relative "../archive_store"
 require_relative "../session_metrics"
@@ -108,10 +111,31 @@ module Samagotchi
           # chi REPL's (only a worker shares it).
           pending_question: session.waiting_question(live: !!owner&.worker?),
           pending_card: up ? Bridge::PendingCard.read(session_dir) : nil,
-          last_turn: session.last_turn&.to_file
+          last_turn: session.last_turn&.to_file,
+          # Its Verify verdicts, the fresh ones its worker hasn't taken yet
+          # too (VerifyFresh.verdicts_of), and the fresh checks running now
+          # ({of, child_id}: the card's "verifying fresh" and its link).
+          verdicts: VerifyFresh.verdicts_of(session, session_dir),
+          verify_fresh: VerifyFresh.running(session.id, state_dir: File.dirname(session_dir))
+                                   .map { |row| { of: row[:of], child_id: row[:child_id] } },
+          last_verdict: last_verdict(session, session_dir)
         }
       end
 
+      def last_verdict(session, session_dir)
+        raw = Array(session.verdicts).last
+        return unless raw.is_a?(Hash)
+
+        verdict = raw.to_h { |key, value| [key.to_sym, value] }
+        author = verdict[:by]
+        return verdict unless Steer.participant_author?(author)
+
+        participant = Participants.read(session.id, state_dir: File.dirname(session_dir))
+                                  .find { |entry| entry.id == Steer.participant_id(author) }
+        participant ? verdict.merge(by_name: participant.name) : verdict
+      end
+      private_class_method :last_verdict
+
       # The budget resolver SessionMetrics.saved_summary takes: a callable,
       # so the session's llm_context budget (config + the registry's index,
       # no network) is resolved only for a session that has a saved context

data/lib/samagotchi/web/verify_fresh_routes.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../delivery"
+require_relative "../participant_mode"
+require_relative "../participant_messages"
+require_relative "../participants"
+require_relative "../session"
+require_relative "../steer"
+require_relative "../verify_fresh"
+
+module Samagotchi
+  module Web
+    # POST /api/sessions/:id/verdicts/:check_turn_id/fresh, mixed into App:
+    # Verify fresh (VerifyFresh) for the owner and for a participant. A
+    # participant's is refused as their turn would be (their cap, counted
+    # with their fresh children's spend; a worker that predates
+    # participants' turns) and audited like one (participants.log,
+    # verify_fresh); their child runs under the boundary their grant has
+    # here now (ParticipantMode.live_for), saved on the child. See
+    # docs/internals/participants.md (Verify fresh).
+    module VerifyFreshRoutes
+      private
+
+      # Whose child it is (D6, the security review's MED-2): a verdict a
+      # participant's turn recorded is re-checked AS that participant
+      # (their author, their grant's mode, their cap), whoever clicks: its
+      # quote is their text, never run with the owner's power. Their link
+      # must still be live (else 409 author_link_ended). An owner's verdict
+      # is re-checked as whoever clicks: the owner's child for the owner, the
+      # clicking participant's for a participant. A participant who clicks
+      # passes their own turn's refusals first.
+      # @return 202 {of, running: true} (+child_id+ for the owner only)
+      def handle_verify_fresh(req, id, of)
+        clicker = principal(req).owner? ? nil : principal(req).grant
+        session = @session_class.load(id, state_dir: default_state_dir)
+        if clicker && (refused = participant_cap_refusal(clicker) || fresh_worker_refusal(session))
+          return verify_fresh_refused(clicker, of, *refused)
+        end
+
+        by = Steer.sender_author(field_of(VerifyFresh.original(session.verdicts, of), :by))
+        runner = by ? verdict_author_grant(id, by) : clicker
+        return author_link_ended(clicker, id, of, by) if by && runner.nil?
+        if runner && runner != clicker && (refused = participant_cap_refusal(runner) || fresh_worker_refusal(session))
+          return verify_fresh_refused(clicker, of, *refused, runner: runner)
+        end
+
+        mode = runner && ParticipantMode.live_for(session, runner, state_dir: default_state_dir)
+        child = VerifyFresh.start(id, of: of, author: runner&.author, mode: mode, state_dir: default_state_dir,
+                                      spawn: fresh_spawn)
+        audit_verify_fresh(clicker, of, status: "accepted", child: child.id, mode: mode&.to_s, runner: runner)
+        json_response(202, clicker ? { of: of, running: true } : { of: of, running: true, child_id: child.id })
+      rescue VerifyFresh::Refused => e
+        verify_fresh_refused(clicker, of, e.status, e.code, e.message, runner: runner)
+      end
+
+      # The live grant of the participant +author+ ("p:<id>") in session
+      # +id+, nil when it is gone, revoked or expired.
+      def verdict_author_grant(id, author)
+        grant = @grants.find(Steer.participant_id(author))
+        grant if grant && grant.session_id == id && grant.active?(@grants.now)
+      end
+
+      # 409 author_link_ended: the verdict's participant can't be charged or
+      # bounded any more, so no child runs for it.
+      def author_link_ended(clicker, id, of, author)
+        pid = Steer.participant_id(author)
+        name = Participants.read(id, state_dir: default_state_dir).find { |entry| entry.id == pid }&.name
+        name = pid if name.to_s.strip.empty?
+        detail = format(AUTHOR_LINK_ENDED, name: name)
+        audit_verify_fresh(clicker, of, status: "refused", reason: "author_link_ended", participant_id: pid) if clicker
+        error_response(409, "author_link_ended", detail)
+      end
+
+      AUTHOR_LINK_ENDED = "%<name>s's link has ended: their verdict can't be checked again as theirs " \
+                          "(re-invite them, or verify the claim yourself)"
+
+      def field_of(record, key) = record && (record[key] || record[key.to_s])
+
+      # A live worker of the session that predates participants' turns runs
+      # no participant's turn (Delivery::REVIEW_UNAVAILABLE): no fresh
+      # child for one either. nil to go on.
+      def fresh_worker_refusal(session)
+        features = ParticipantMode.live_features(session, default_state_dir)
+        return nil if features.nil? || features.include?(Delivery::REVIEW_FEATURE)
+
+        [409, Delivery::REVIEW_UNAVAILABLE["error"], Delivery::REVIEW_UNAVAILABLE["detail"]]
+      end
+
+      def verify_fresh_refused(clicker, of, status, code, detail, runner: nil)
+        audit_verify_fresh(clicker, of, status: "refused", reason: code, runner: runner)
+        error_response(status, code, detail)
+      end
+
+      # Audited in the participants' trail when a participant clicked or the
+      # child runs as one: +clicker+ the participant who asked (nil: the
+      # owner), +runner+ whose child it is.
+      def audit_verify_fresh(clicker, of, status:, runner: nil, participant_id: nil, **fields)
+        subject = runner || clicker
+        return if subject.nil? && participant_id.nil?
+
+        Participants.log(subject&.session_id || clicker.session_id, :verify_fresh, state_dir: default_state_dir,
+                                                                                   participant: subject&.id || participant_id,
+                                                                                   asked_by: clicker ? clicker.id : "owner",
+                                                                                   of: of.to_s[0, 64], status: status, **fields.compact)
+      end
+
+      def fresh_spawn = ->(**options) { @manager.spawn_session(**options) }
+    end
+  end
+end

data/lib/samagotchi/worker.rb

@@ -21,6 +21,7 @@ require_relative "worker_signals"
 require_relative "worker_task_wakes"
 require_relative "session_manager"
 require_relative "archive_store"
+require_relative "reminder_carry"
 require_relative "log"
 require_relative "turn_flow"
 require_relative "turn_checkpoint"
@@ -32,6 +33,7 @@ require_relative "session_setting"
 require_relative "queued_command"
 require_relative "model_profile"
 require_relative "child_reports"
+require_relative "verify_fresh"
 require_relative "child_move"
 require_relative "context_absorber"
 require_relative "context_poller"
@@ -248,7 +250,11 @@ module Samagotchi
       drop_dead_question
       # The running turn, on disk at its iteration boundaries.
       @checkpoint = TurnCheckpoint.new(session: @session, state_dir: @state_dir)
+      # A restart's hand-off, checked before the Engine's build (its window
+      # runs from the leave) and restored into it after.
+      carried = take_carried_reminders
       @engine = build_engine
+      restore_carried_reminders(carried)
       @config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :worker) do |message|
         @engine.announce(type: :hook_notice, hook: "config", text: message, level: :warn, between_turns: true)
       end
@@ -418,6 +424,7 @@ module Samagotchi
       # A change that asks to wake may start a turn here (C4), but not
       # ahead of an exit or restart a client asked for: it is a note then.
       @inbound.absorb_notes
+      absorb_fresh_verdicts
       return if absorb_context(wake: nothing_queued? && !@exit_requested)
 
       if (prompt = @inbound.take_initial_prompt)
@@ -446,7 +453,9 @@ module Samagotchi
       return if run_task_wake
       return if run_due_reminders
       return left(:idle_exit) if @idle_exit.due? && leave_idle
-      return left(@exit_restart ? :restart : :exit_requested) if @exit_requested && leave_on_request
+
+      leaving = @exit_requested && leave_on_request
+      return left(leaving) if leaving
 
       watch_participants
       @waker.wait(idle_wait)
@@ -652,9 +661,13 @@ module Samagotchi
     # The first prompt (spawn_session's): a delegate child's task, which is
     # its parent's although no client sent it. Its turn carries the id
     # spawn_session gave it, so a wait for it (--new --wait) names it.
+    # A Verify fresh child's is a Verify turn on its claim (its verdict is
+    # recorded and forwarded to the parent).
     def run_initial_prompt(prompt)
       @initial_turn = true
-      run_prompt(WorkerInbound::Prompt.new(text: prompt, origin: TurnOrigin.new(enqueued_id: @session.first_turn_id)))
+      fresh = @session.verify_fresh
+      run_prompt(WorkerInbound::Prompt.new(text: prompt, origin: TurnOrigin.new(enqueued_id: @session.first_turn_id),
+                                           verify: fresh&.anchor))
     ensure
       @initial_turn = false
     end
@@ -665,7 +678,7 @@ module Samagotchi
 
     # @param prompt [WorkerInbound::Prompt]
     def run_prompt(prompt)
-      origin = prompt.origin
+      origin = fresh_origin(prompt.origin)
       # A participant's turn queued before their link ended or their cap was
       # reached doesn't start (chi web refuses new ones; this is the
       # worker's check).
@@ -681,7 +694,7 @@ module Samagotchi
       @continue_offer.drop(origin)
       @turn_flow.before_prompt_turn
       run_engine_turn(prompt.text, origin: origin, max_iterations: max_iterations(prompt.no_interrupt),
-                                   images: prompt.images) do |result, error|
+                                   images: prompt.images, **(prompt.verify ? { verify: prompt.verify } : {})) do |result, error|
         if error
           # The Engine announced :turn_failed (with the error's one line).
           restore_failed_turn([[prompt.text, origin, prompt.images], *@merged_this_turn], error: error)
@@ -692,6 +705,13 @@ module Samagotchi
       participant_refusal(origin.author)
     end
 
+    # +origin+ as this session's turns run it: a participant's Verify fresh
+    # child's are all theirs (VerifyFreshOrigin#origin_for).
+    def fresh_origin(origin)
+      fresh = @session&.verify_fresh
+      fresh ? fresh.origin_for(origin) : TurnOrigin.of(origin)
+    end
+
     # Why the participant +author+ ("p:<id>") may run no more turns, nil
     # while they may (and for the owner): "revoked" when participants.json
     # has no active entry for them (revoked, expired, never invited),
@@ -701,11 +721,11 @@ module Samagotchi
     def participant_refusal(author)
       author = Steer.sender_author(author) or return nil
 
-      entry = Participants.read(@session_id, state_dir: @state_dir).find { |e| Steer.author_for(e.id) == author }
+      entry = participant_entry(author)
       return "revoked" unless entry&.active?(Time.now)
 
       cap = participant_cap(entry)
-      return nil if @engine.metrics.spend(author) < cap
+      return nil if participant_spend(author) < cap
 
       cap_notice(author, entry, cap)
       "cap_reached"
@@ -718,13 +738,30 @@ module Samagotchi
     def participant_turn_stop(author)
       reason = participant_refusal(author) or return nil
 
-      entry = Participants.read(@session_id, state_dir: @state_dir).find { |e| Steer.author_for(e.id) == author }
+      entry = participant_entry(author)
       name = participant_label(author, entry&.name)
       return format(REVOKED_STOP, name: name) if reason == "revoked"
 
       format(CAP_STOP, name: name, cap: participant_cap(entry))
     end
 
+    # +author+'s participants.json entry: this session's, a Verify fresh
+    # child's parent's (Session#participants_source_id); nil for none.
+    def participant_entry(author)
+      Participants.read(participants_id, state_dir: @state_dir).find { |e| Steer.author_for(e.id) == author }
+    end
+
+    # The session whose participants.json and audit trail this session's
+    # participants are in.
+    def participants_id = @session&.participants_source_id || @session_id
+
+    # What +author+ spent against their cap: this session's metrics (live)
+    # and, through Verify fresh, the parent's or the children's saved ones
+    # (VerifyFresh.related_spend).
+    def participant_spend(author)
+      @engine.metrics.spend(author) + VerifyFresh.related_spend(@session, author, state_dir: @state_dir)
+    end
+
     # A participant's cap in dollars: their own, else the config's.
     def participant_cap(entry) = entry&.cap.is_a?(Numeric) ? entry.cap.to_f : Web::Grants.default_cap
 
@@ -746,7 +783,7 @@ module Samagotchi
       id = Steer.participant_id(author)
       text = ParticipantMode.for_turn(@session, entry) == ParticipantMode::PAIR ? PAIR_CAP_NOTICE : CAP_NOTICE
       @engine.announce(type: :hook_notice, hook: Engine::PARTICIPANTS_HOOK, level: :warn, between_turns: true,
-                       text: format(text, name: participant_label(author, entry.name), cap: cap, session: @session_id[0, 8], id: id))
+                       text: format(text, name: participant_label(author, entry.name), cap: cap, session: participants_id[0, 8], id: id))
     end
 
     CAP_NOTICE = "%<name>s reached their $%<cap>.2f review cap: their comments are refused until you raise it " \
@@ -767,7 +804,7 @@ module Samagotchi
     # @param origin [TurnOrigin] a participant's
     def refuse_participant_turn(origin, reason)
       TurnCheckpoint.record_refused(@session_dir, origin.enqueued_id, reason: reason, author: origin.participant_author)
-      Participants.log(@session_id, :turn, state_dir: @state_dir, participant: origin.participant_id,
+      Participants.log(participants_id, :turn, state_dir: @state_dir, participant: origin.participant_id,
                                            enqueued_id: origin.enqueued_id, status: "refused", reason: reason)
       @engine.announce(type: :turn_dequeued, enqueued_id: origin.enqueued_id, client_id: origin.client_id)
       nil
@@ -1189,7 +1226,9 @@ module Samagotchi
       # Every kind of turn merges steering (a reminder turn too, which may be
       # a fresh worker's first), so the list is this turn's from the start.
       @merged_this_turn = []
-      origin = TurnOrigin.of(turn_args[:origin])
+      origin = fresh_origin(turn_args[:origin])
+      turn_args = turn_args.merge(origin: origin)
+      verdicts_before = @session.verdicts.size
       @reporting_turn = reports_to_parent?(origin)
       # A participant's review turn merges no input (#pending_input_drain).
       @participant_turn = origin.participant?
@@ -1234,6 +1273,33 @@ module Samagotchi
       # turn that failed (kept with its failed note), read them.
       settle_child_reports(rolled_back: @turn_flow.restores != restores || merges_lost?(error))
       ring_parent_after_turn
+      forward_fresh_verdicts(verdicts_before)
+    end
+
+    # A Verify fresh child's verdicts this turn recorded go to its parent
+    # (VerifyFresh.forward), after the save: the parent's card shows them.
+    # A fresh child never rings (ChildRing.ring): nothing enters the
+    # parent's conversation.
+    def forward_fresh_verdicts(before)
+      return unless @session.verify_fresh
+
+      added = @session.verdicts.drop(before)
+      VerifyFresh.forward(@session, added, state_dir: @state_dir) unless added.empty?
+    end
+
+    # The parent's side, between turns: the verdicts its Verify fresh
+    # children forwarded join the session's (saved, then their files go)
+    # and the UIs hear each (:verdict_recorded).
+    def absorb_fresh_verdicts
+      added, files = VerifyFresh.take(@session, @session_dir)
+      return if files.empty?
+
+      return unless save_or_log(:fresh_verdicts) { save_session }
+
+      FileUtils.rm_f(files)
+      added.each { |record| @engine.announce(type: :verdict_recorded, verdict: record) }
+    rescue StandardError => e
+      Log.warn(:worker, "fresh_verdicts_failed", error: e.class.name, msg: e.message)
     end
 
     # The delegate reports this turn took: a kept turn moves the cursors on
@@ -1514,6 +1580,11 @@ module Samagotchi
     def exit_request(client_id, delete: false, restart: false, stop: false, ask: true)
       # The Bridge serves before the idle-exit policy exists.
       return WorkerIdleExit::Hold.new(reason: :starting) unless @idle_exit
+      # One exit is already taken: the first one decides how the worker
+      # leaves (a later stop-all can't turn a restart, whose reminders go to
+      # the next worker, into a plain exit). Held at the leave, it is
+      # forgotten and the next request counts again.
+      return nil if @exit_requested
 
       if restart
         hold = @idle_exit.hold_for_restart
@@ -1551,7 +1622,8 @@ module Samagotchi
     # intake and stop the idle jobs (the Bridge stops after the log). Other clients' streams no longer hold: the asker's
     # may not have closed yet, and a UI joining now finds the worker gone
     # (:stream_closed), the window #leave_idle has too.
-    # @return [Boolean] false when something came in since the request
+    # @return [Symbol, false] how it leaves (:restart or :exit_requested,
+    #   decided under the lock), false when something came in since the request
     def leave_on_request
       stop_bridge_after do
         @engine.synchronize_events do
@@ -1566,16 +1638,57 @@ module Samagotchi
             Log.info(:worker, "exit_held", reason: hold)
             next false
           end
+          next false if @exit_restart && !carry_reminders
 
           @bridge&.close_intake
           # Not joined: a recap tick's emit waits for the event log held here.
           @engine.stop_idle(join: false)
           Log.info(:worker, @exit_restart ? "restart_requested" : "exit_requested", by: @exit_requested_by || "a client")
-          true
+          @exit_restart ? :restart : :exit_requested
         end
       end
     end
 
+    # A restart hands the reminders to the next worker (ReminderCarry), while
+    # the event log is held: no turn can register or fire one from here. A
+    # write that fails keeps this worker up with them rather than losing them.
+    # A session stopped meanwhile drops them (run_session_loop then starts no
+    # successor): nothing is written.
+    # @return [Boolean] false when the write failed
+    def carry_reminders
+      if stopped_on_disk?
+        ReminderCarry.remove(@session_dir)
+      else
+        ReminderCarry.write(@session_dir, session_id: @session_id, store: @engine.reminder_store)
+      end
+      true
+    rescue StandardError => e
+      @exit_requested = nil
+      @exit_restart = false
+      Log.warn(:worker, "reminders_carry_failed", error: e.class.name, msg: e.message)
+      false
+    end
+
+    # The reminders a restart handed over (#carry_reminders), read and
+    # deleted; a stopped session drops them.
+    # @return [Array<Hash>, nil] ReminderStore#export's entries
+    def take_carried_reminders
+      ReminderCarry.take(@session_dir, session_id: @session_id, stopped: stopped_on_disk?)
+    rescue StandardError => e
+      Log.warn(:worker, "reminders_carry_take_failed", error: e.class.name, msg: e.message)
+      nil
+    end
+
+    # Into the new Engine's store, before the idle scheduler starts polling it.
+    def restore_carried_reminders(entries)
+      return unless entries
+
+      names = @engine.reminder_store.restore(entries)
+      Log.info(:worker, "reminders_carried", count: names.size)
+    rescue StandardError => e
+      Log.warn(:worker, "reminders_carry_restore_failed", error: e.class.name, msg: e.message)
+    end
+
     # @return [Symbol] +result+, with #discard? decided and, for a session
     #   kept, its recap written: the Bridge is closed and the idle jobs are
     #   stopped by now, and nothing waits on this (the TUI has detached). A

data/lib/samagotchi/worker_idle_exit.rb

@@ -11,7 +11,8 @@ module Samagotchi
   # * a client holds the Bridge's stream (an attached TUI, even an idle one,
   #   or a web tab);
   # * a reminder is registered. Reminders live only in the Engine and repeat
-  #   until the agent cancels them, so an exit would drop them for good;
+  #   until the agent cancels them, so an exit would drop them for good (a
+  #   restart hands them to the next worker instead: ReminderCarry);
   # * a continue offer waits for an answer; it too lives only in memory;
   # * a background task the worker watches for a finish wake (TaskWatch)
   #   still runs, or finished and waits for the next pass's wake: its end
@@ -167,18 +168,18 @@ module Samagotchi
     # approval waiting (a turn's), a /btw (or another anytime command)
     # running, a delegate's approval relay this worker still answers for,
     # background tasks this conversation started (their output and end are
-    # this worker's to report). Clients' streams don't hold: a web tab
-    # reconnects on the new worker's bridge_up, an attached terminal finds
-    # the new worker's Bridge.
+    # this worker's to report). Reminders don't hold: the worker writes them
+    # for its successor as it leaves (Worker#leave_on_request, ReminderCarry).
+    # Clients' streams don't hold either: a web tab reconnects on the new
+    # worker's bridge_up, an attached terminal finds the new worker's Bridge.
     # @return [Symbol, nil] :turn_running, :input_queued, :continue_offered,
-    #   :question_pending, :reminders, :command_running, :relays_open or
+    #   :question_pending, :command_running, :relays_open or
     #   :background_tasks
     def hold_for_restart
       return :turn_running if @engine.turn_running?
       return :input_queued if @input_pending.call
       return :continue_offered if @awaiting_continue.call
       return :question_pending if @engine.pending_question
-      return :reminders if @engine.reminder_store&.any?
       return :command_running if @engine.anytime_running?
       return :relays_open if @engine.relay_desk.active?
       return :background_tasks if @running_tasks.call.any?

data/lib/samagotchi/worker_inbound.rb

@@ -40,9 +40,9 @@ module Samagotchi
     # turn; +images+: its image refs ({file:, name:}); +delivery+: the wire
     # value the sender asked for ("queue", or nil for the default
     # next_step); +origin+: a TurnOrigin (a Hash is read as one).
-    Prompt = Data.define(:text, :origin, :no_interrupt, :images, :delivery) do
-      def initialize(text:, origin: nil, no_interrupt: false, images: [], delivery: nil)
-        super(text:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:)
+    Prompt = Data.define(:text, :origin, :no_interrupt, :images, :delivery, :verify) do
+      def initialize(text:, origin: nil, no_interrupt: false, images: [], delivery: nil, verify: nil)
+        super(text:, origin: TurnOrigin.of(origin), no_interrupt:, images:, delivery:, verify: VerifyAnchor.from(verify))
       end
     end
 
@@ -215,7 +215,7 @@ module Samagotchi
         return if input.images.empty? && queue_as_command(input.prompt, input.origin, File.basename(input_file))
 
         yield Prompt.new(text: input.prompt, origin: input.origin, no_interrupt: input.no_interrupt, images: input.images,
-                         delivery: input.delivery)
+                         delivery: input.delivery, verify: input.verify)
       ensure
         FileUtils.rm_f(claimed_file)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.124.0
+  version: 0.126.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -528,6 +528,7 @@ files:
 - lib/samagotchi/relay_desk.rb
 - lib/samagotchi/relay_verifier.rb
 - lib/samagotchi/relay_watcher.rb
+- lib/samagotchi/reminder_carry.rb
 - lib/samagotchi/reminder_queue.rb
 - lib/samagotchi/reminder_store.rb
 - lib/samagotchi/remote_attach_command.rb
@@ -603,13 +604,20 @@ files:
 - lib/samagotchi/terminal_ui/attach_launcher.rb
 - lib/samagotchi/terminal_ui/attach_link.rb
 - lib/samagotchi/terminal_ui/attached_loop.rb
+- lib/samagotchi/terminal_ui/attached_loop/composer.rb
+- lib/samagotchi/terminal_ui/attached_loop/exit_commands.rb
+- lib/samagotchi/terminal_ui/attached_loop/questions.rb
+- lib/samagotchi/terminal_ui/attached_loop/queueing.rb
+- lib/samagotchi/terminal_ui/attached_loop/sending.rb
 - lib/samagotchi/terminal_ui/attached_view.rb
 - lib/samagotchi/terminal_ui/between_turns.rb
 - lib/samagotchi/terminal_ui/event_renderer.rb
+- lib/samagotchi/terminal_ui/exit_lines.rb
 - lib/samagotchi/terminal_ui/formatting.rb
 - lib/samagotchi/terminal_ui/gap_clock.rb
 - lib/samagotchi/terminal_ui/image_input.rb
 - lib/samagotchi/terminal_ui/input_support.rb
+- lib/samagotchi/terminal_ui/join_replay.rb
 - lib/samagotchi/terminal_ui/line_reader.rb
 - lib/samagotchi/terminal_ui/live_region.rb
 - lib/samagotchi/terminal_ui/local_link.rb
@@ -719,6 +727,10 @@ files:
 - lib/samagotchi/update_hint.rb
 - lib/samagotchi/used_memories.rb
 - lib/samagotchi/utf8_default.rb
+- lib/samagotchi/verdict.rb
+- lib/samagotchi/verify_anchor.rb
+- lib/samagotchi/verify_fresh.rb
+- lib/samagotchi/verify_fresh_origin.rb
 - lib/samagotchi/version.rb
 - lib/samagotchi/vision_context.rb
 - lib/samagotchi/vision_support.rb
@@ -757,6 +769,7 @@ files:
 - lib/samagotchi/web/public/chains.js
 - lib/samagotchi/web/public/chip_popover.js
 - lib/samagotchi/web/public/chunk_router.js
+- lib/samagotchi/web/public/claim_link.js
 - lib/samagotchi/web/public/command_complete.js
 - lib/samagotchi/web/public/command_list.js
 - lib/samagotchi/web/public/command_view.js
@@ -871,6 +884,10 @@ files:
 - lib/samagotchi/web/public/vendor/directives/repeat.js
 - lib/samagotchi/web/public/vendor/directives/unsafe-html.js
 - lib/samagotchi/web/public/vendor/lit-html.js
+- lib/samagotchi/web/public/verdict_card.js
+- lib/samagotchi/web/public/verdict_fresh.js
+- lib/samagotchi/web/public/verify_card.css
+- lib/samagotchi/web/public/verify_preset.js
 - lib/samagotchi/web/public/working_set.js
 - lib/samagotchi/web/public/working_set_rail.js
 - lib/samagotchi/web/public/working_set_view.js
@@ -897,6 +914,7 @@ files:
 - lib/samagotchi/web/tunnel.rb
 - lib/samagotchi/web/tunnel/tailscale.rb
 - lib/samagotchi/web/update_check.rb
+- lib/samagotchi/web/verify_fresh_routes.rb
 - lib/samagotchi/worker.rb
 - lib/samagotchi/worker_idle_exit.rb
 - lib/samagotchi/worker_inbound.rb