samagotchi 0.127.0 → 0.129.0

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -71,7 +71,8 @@ module Samagotchi
       #   TUI's streams and requests there (#client_id)
       # @return [Symbol] :detached, :closed when the worker went away,
       #   :failed when the --model switch didn't go through, or (input from a
-      #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
+      #   pipe) :turn_failed / :empty_answer / :removed / :unanswered
+      #   (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
               memories: [], muted_memories: [], llm_context: {}, thinking: nil, appended_prompt_files: [], toolkit: nil,
               toolkit_flags: [], settings: nil, parent_answers: nil, state_dir: nil, connector: nil)
@@ -146,11 +147,14 @@ module Samagotchi
         err.flush
       end
 
-      # A turn of ours that ended with no answer (input from a pipe): one
-      # line on stderr, as the in-process `chi -p --non-interactive` says
-      # it, so a script doesn't take the silence for an answer (exit 1).
+      # An own turn with no answer, or a prompt removed before it ran
+      # (input from a pipe): one line on stderr, so a script doesn't take
+      # the silence for an answer (exit 1).
       def report_ended(ended, err: $stderr)
-        err.puts(TerminalUI::EMPTY_ANSWER_ERROR) if ended == :empty_answer
+        case ended
+        when :empty_answer then err.puts(TerminalUI::EMPTY_ANSWER_ERROR)
+        when :removed then err.puts("chi: the prompt was removed before it ran")
+        end
       end
 
       # chi's exit status after #run: 0 detached, 3 a question left waiting

data/lib/samagotchi/terminal_ui/attached_loop/queueing.rb

@@ -7,8 +7,8 @@ module Samagotchi
     class AttachedLoop
       # Queue and unqueue handling for the attached loop.
       # Reads @client, @client_id, @first_command_id, @link, @my_queued,
-      # @open_ids, @reader, @screen, @shown_enqueued, @wait_at_eof; writes
-      # @my_queued, @open_ids, @own_empty, @own_failed, @prefilled, @queued_ids,
+      # @own_turns, @reader, @screen, @shown_enqueued, @wait_at_eof; writes
+      # @my_queued, @prefilled, @queued_ids,
       # @shown_enqueued.
       # Calls the loop helpers #author_of, #first_command_flag, #mark_activity,
       # #own?, #prompt_line, #send_prompt, #via, and #worker_down.
@@ -131,19 +131,13 @@ module Samagotchi
 
         # A queued prompt was taken back before it ran (the web's ×, /unqueue
         # in a terminal). One of this run's (wait_at_eof) will have no turn:
-        # it ends the wait, as a failed one does. Another client's shown
-        # line says so.
+        # it ends the wait as :removed. Another client's shown line says so.
         def turn_dequeued(event)
           id = event[:enqueued_id]
           @my_queued.delete(id)
-          if @open_ids.delete?(id)
-            if own?(event[:client_id])
-              @own_empty = true
-              @screen.commit("(removed before it ran)")
-            else
-              @own_failed = true
-              @screen.commit("(your queued message was removed before it ran)")
-            end
+          by_us = own?(event[:client_id])
+          if @own_turns.dequeued(id, by_us: by_us)
+            @screen.commit(by_us ? "(removed before it ran)" : "(your queued message was removed before it ran)")
           elsif @shown_enqueued.delete?(id)
             @screen.commit("(a queued message was removed)")
           end

data/lib/samagotchi/terminal_ui/attached_loop/sending.rb

@@ -10,19 +10,16 @@ require_relative "../image_input"
 module Samagotchi
   class TerminalUI
     class AttachedLoop
-      # Bridge sending, first-command launch, and this run's turn ledger.
-      # Reads @as_parent, @client, @client_id, @display_pending, @first_command_id,
-      # @first_command_line, @first_commands, @first_prompt, @input_ended, @link,
-      # @merged_ids, @my_queued, @no_interrupt, @open_ids, @own_empty, @own_failed,
-      # @queued_ids, @reader, @running, @screen, @sent_ids, @status, @wait_at_eof;
-      # writes @display_pending, @first_command_id, @first_command_line,
-      # @first_commands, @first_prompt, @merged_ids, @my_queued, @open_ids,
-      # @own_empty, @own_failed, @queued_ids, @sent_ids.
-      # Calls the loop helpers #client_id_for, #command_registry, #default_model_name,
-      # #detach, #mark_activity, #older_worker_command, #origin_of, #own?, #paint,
-      # #persist_recent_history, #prompt_line, #put_back_busy_command, #prefill_confirm,
-      # #queue_needs_newer_worker, #send_command, #send_prompt, #stale_worker,
-      # #steer_cut_note, #too_late?, #via, and #worker_down.
+      # Bridge sending and first-command launch.
+      # Reads @as_parent, @client, @client_id, @first_command_id, @first_command_line,
+      # @first_commands, @first_prompt, @link, @my_queued, @no_interrupt, @own_turns,
+      # @queued_ids, @reader, @running, @screen, @status;
+      # writes @first_command_id, @first_command_line, @first_commands, @first_prompt,
+      # @my_queued, @queued_ids.
+      # Calls the loop helpers #command_registry, #default_model_name, #detach,
+      # #mark_activity, #older_worker_command, #origin_of, #own?, #paint,
+      # #persist_recent_history, #prompt_line, #queue_needs_newer_worker,
+      # #stale_worker, #steer_cut_note, #too_late?, #via, and #worker_down.
       module Sending
         private
 
@@ -33,7 +30,7 @@ module Samagotchi
           if reply.status == 202
             # Input from a pipe ends once its output is in (#command_ran).
             command_id = reply.json&.fetch("command_id", nil)
-            @open_ids << command_id if command_id && @wait_at_eof
+            @own_turns.command_sent(command_id) if command_id
             return
           end
           return @screen.commit(stale_worker("run commands")) if reply.status == 404
@@ -49,7 +46,7 @@ module Samagotchi
         end
 
         def command_ran(event)
-          @open_ids.delete(event[:command_id])
+          @own_turns.command_ran(event[:command_id])
           @queued_ids.delete(event[:command_id])
           unless own?(event[:client_id]) || event[:anytime] || event[:card] || event[:queued]
             @screen.commit(prompt_line(event[:client_id], event[:line]))
@@ -147,8 +144,7 @@ module Samagotchi
           reply = @client.post_turn(**options)
           if reply.status == 202
             enqueued_id = reply.json&.fetch("enqueued_id", nil)
-            @sent_ids << enqueued_id if enqueued_id
-            @open_ids << enqueued_id if enqueued_id && @wait_at_eof
+            @own_turns.sent(enqueued_id) if enqueued_id
             @my_queued << enqueued_id if enqueued_id && reply.json&.fetch("delivery", nil) == Delivery::QUEUE
             note = sent_note(reply.json, delivery: delivery, images: images, running: running, choice: choice)
             @screen.commit(note) if note
@@ -172,21 +168,15 @@ module Samagotchi
         # Whether the input's end must wait: the -p prompt isn't sent yet, a
         # prompt this run sent hasn't had its turn, or its turn's after_turn
         # hooks still run (their notices, source-links' sources:, come next).
-        def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty? || @display_pending == true
+        def own_turns_pending? = !@first_prompt.to_s.strip.empty? || @own_turns.pending?
 
         # A turn ended: this run's prompt (and ours merged into it) had its turn.
         def own_turn_ended(event)
-          return unless @wait_at_eof
-
-          id = origin_of(event[:origin]).enqueued_id
-          ours = @open_ids.include?(id) || !@merged_ids.empty?
-          @own_failed = true if ours && event[:type] == :turn_failed
-          @own_empty = true if ours && event[:type] == :turn_completed && event.dig(:turn_summary, :empty_answer)
-          # The worker sends answer_display once its after_turn hooks ran.
-          @display_pending = true if ours && event[:type] == :turn_completed && event[:display_pending]
-          @open_ids.delete(id)
-          @open_ids.subtract(@merged_ids)
-          @merged_ids.clear
+          completed = event[:type] == :turn_completed
+          @own_turns.ended(origin_of(event[:origin]).enqueued_id,
+                           failed: event[:type] == :turn_failed,
+                           empty: completed && event.dig(:turn_summary, :empty_answer),
+                           display_pending: completed && event[:display_pending])
         end
 
         # Ours merged into the running turn: they end with it.
@@ -194,22 +184,20 @@ module Samagotchi
           Array(event[:origins]).each do |value|
             origin = origin_of(value)
             id = origin.enqueued_id
-            @merged_ids << id if own?(origin.client_id) && @open_ids.include?(id)
+            @own_turns.merged(id) if own?(origin.client_id)
           end
           nil
         end
 
         def own_prompt_failed
-          @own_failed = true if @wait_at_eof
+          @own_turns.prompt_failed
           nil
         end
 
         # The input ended and nothing of ours is left to wait for.
         def end_of_input
-          detach("Detached; the session keeps running. Re-attach with: #{via.attach(@client.session_id)}") if @input_ended
-          return :turn_failed if @own_failed
-
-          @own_empty ? :empty_answer : :detached
+          detach("Detached; the session keeps running. Re-attach with: #{via.attach(@client.session_id)}") if @own_turns.input_ended?
+          @own_turns.outcome
         end
 
         # The prompt's `@path` images, stored where the worker reads them

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -14,6 +14,7 @@ require_relative "image_input"
 require_relative "line_reader"
 require_relative "question_prompt"
 require_relative "join_replay"
+require_relative "own_turns"
 require_relative "exit_lines"
 require_relative "attached_loop/exit_commands"
 require_relative "attached_loop/questions"
@@ -68,8 +69,7 @@ module Samagotchi
       attr_reader :client_id
 
       # @return [String, nil] the model the worker's turns run on, as the
-      #   last command said
-      # @return [String, nil] the worker's model
+      #   last snapshot or model change said (the status row's)
       def model_name = @status[:model]
 
       # @return [QuestionPrompt, nil] the question waiting for an answer
@@ -152,21 +152,12 @@ module Samagotchi
         @join_replay = JoinReplay.new(screen: @screen, view: @view, link: @link, gaps: @gaps, renderer: @renderer)
         @last_idle_interrupt_at = nil
         @next_input_prefill = nil
-        # Prompts this run sent, by enqueued_id: only those come back into
-        # the input when their turn fails (a replayed event must not).
-        @sent_ids = Set.new
         # This run's prompts queued for after the running turn (their ack
         # said queue), oldest first, until their turn starts or they are
         # removed: /unqueue takes back the newest.
         @my_queued = []
         @wait_at_eof = wait_at_eof
-        # Sent and not ended yet (by enqueued_id), the ones merged into the
-        # running turn, whether the input has ended, and whether one of this
-        # run's prompts failed (wait_at_eof only).
-        @open_ids = Set.new
-        @merged_ids = Set.new
-        @input_ended = false
-        @own_failed = false
+        @own_turns = OwnTurns.new(active: wait_at_eof)
         # A continue offer is pending: the prompt asks for the answer.
         @continue_offer = nil
         # The /exit ask is open: the next line is its answer (#answer_exit_ask).
@@ -188,7 +179,8 @@ module Samagotchi
       #   :failed when the first command (--model) didn't go through, or
       #   (wait_at_eof) :turn_failed when one of this run's prompts failed,
       #   :empty_answer when one ended with no answer, and :unanswered when
-      #   a question came after the input ended
+      #   a question came after the input ended; :removed when this run took
+      #   back its only queued prompt before it ran
       # @param input [#call, nil] prompt -> line (nil = Ctrl-D, raising
       #   Interrupt = Ctrl-C); defaults to Reline
       def run(input: nil)
@@ -225,7 +217,7 @@ module Samagotchi
 
             ended = take_early_lines
             return ended if ended
-            return end_of_input if @input_ended && !own_turns_pending?
+            return end_of_input if @own_turns.input_ended? && !own_turns_pending?
           when :line
             # A pipe is read at once: its lines wait for the joining
             # snapshot, which may bring the question they answer.
@@ -256,7 +248,7 @@ module Samagotchi
           # has nothing left to answer it.
           return unanswered_question(@question_pending) if @question
 
-          @input_ended = true
+          @own_turns.end_input
           return nil
         end
         end_of_input if submit(line) == :detach
@@ -303,7 +295,7 @@ module Samagotchi
           own_turn_ended(event)
         when :prompt_restored then restore_prompt(event)
         # The after_turn hooks are done (their notices came before it).
-        when :answer_display then @display_pending = false
+        when :answer_display then @own_turns.displayed
         when :context_status, :used_memories_updated then @status.take_event(event)
         when :participants_changed then participants_changed(event)
         # Another client's anytime command: its line now, before the cards
@@ -333,7 +325,7 @@ module Samagotchi
           refresh_children if Array(event[:origins]).any? { |origin| report_origin?(origin_of(origin)) }
         when :question_requested
           # Nothing is left to answer it with.
-          return unanswered_question(event[:pending_question]) if @input_ended
+          return unanswered_question(event[:pending_question]) if @own_turns.input_ended?
 
           ask(event[:pending_question])
         when :question_answered then question_answered(event)
@@ -515,7 +507,7 @@ module Samagotchi
       # goes back into the input, as the REPL restores it for a retry.
       def restore_prompt(event)
         origin = origin_of(event[:origin])
-        return unless own?(origin.client_id) && @sent_ids.include?(origin.enqueued_id)
+        return unless own?(origin.client_id) && @own_turns.sent?(origin.enqueued_id)
         # Lines from a pipe: nobody to retry it (the REPL's rule).
         return if @wait_at_eof
 

data/lib/samagotchi/terminal_ui/exit_lines.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../tools/task_record"
+require_relative "../worker_idle_exit"
 
 module Samagotchi
   class TerminalUI
@@ -23,7 +24,7 @@ module Samagotchi
         "reminders" => "reminders are set", "starting" => "the worker is still starting",
         "background_tasks" => "background tasks it started are still running",
         "delegates" => "delegates of this session are still running"
-      }.freeze
+      }.merge(WorkerIdleExit::LEAVING_WORDS.transform_keys(&:to_s)).freeze
       # How to end a background task that holds the worker up (an older
       # worker's 409 has no hint of its own).
       TASK_STOP_HINT = "stop one with the web's stop-task button or by asking for task_stop"

data/lib/samagotchi/terminal_ui/local_link.rb

@@ -57,7 +57,7 @@ module Samagotchi
         id = @session_id
         return [:gone, "stopped"] if Session.stopped_marker?(id, state_dir: @state_dir)
 
-        link = WorkerLink.resolve(session_dir, unlink: true, host: @host)
+        link = WorkerLink.resolve(session_dir, unlink: true)
         if link.is_a?(WorkerLink::Skew)
           @failure = link.message(id)
           return [:gone, "worker_newer"]
@@ -79,7 +79,7 @@ module Samagotchi
         candidate = if found&.port == port
                       found
                     else
-                      link = WorkerLink.resolve(session_dir, unlink: true, host: @host)
+                      link = WorkerLink.resolve(session_dir, unlink: true)
                       link.live? && link.port == port ? link.client(@session_id, host: @host) : nil
                     end
         @client = candidate if candidate

data/lib/samagotchi/terminal_ui/own_turns.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class TerminalUI
+    # This run's own prompts and commands. Sent prompts are always recorded so
+    # only this run's failed prompts can return to the input. With pipe input
+    # (+active+), this also tracks turns still open, prompts merged into a
+    # running turn, whether input ended, and whether a turn failed, was empty, was removed,
+    # or still has an answer display pending. #outcome is what #run returns
+    # once those turns finish.
+    class OwnTurns
+      def initialize(active:)
+        @active = active
+        @sent = Set.new
+        @open = Set.new
+        @merged = Set.new
+        @input_ended = false
+        @failed = false
+        @empty = false
+        @removed = false
+        @display_pending = false
+      end
+
+      def sent(enqueued_id)
+        @sent << enqueued_id
+        @open << enqueued_id if @active
+      end
+
+      def sent?(enqueued_id) = @sent.include?(enqueued_id)
+
+      def command_sent(command_id)
+        @open << command_id if @active
+      end
+
+      def command_ran(command_id) = @open.delete(command_id)
+
+      def merged(enqueued_id)
+        @merged << enqueued_id if @open.include?(enqueued_id)
+      end
+
+      def ended(enqueued_id, failed:, empty:, display_pending:)
+        return unless @active
+
+        ours = @open.include?(enqueued_id) || !@merged.empty?
+        @failed = true if ours && failed
+        @empty = true if ours && empty
+        @display_pending = true if ours && display_pending
+        @open.delete(enqueued_id)
+        @open.subtract(@merged)
+        @merged.clear
+      end
+
+      def displayed = (@display_pending = false)
+
+      def prompt_failed
+        @failed = true if @active
+      end
+
+      def dequeued(enqueued_id, by_us:)
+        return false unless @open.delete?(enqueued_id)
+
+        by_us ? (@removed = true) : (@failed = true)
+        true
+      end
+
+      def end_input = (@input_ended = true)
+
+      def input_ended? = @input_ended
+
+      def pending? = !@open.empty? || @display_pending
+
+      def outcome
+        return :turn_failed if @failed
+        return :empty_answer if @empty
+        return :removed if @removed
+
+        :detached
+      end
+    end
+  end
+end

data/lib/samagotchi/verify_anchor.rb

@@ -25,4 +25,12 @@ module Samagotchi
 
     def to_file = { "turn_id" => turn_id, "quote" => quote }
   end
+
+  VerifyAnchor::FEATURE = "verify"
+  VerifyAnchor::UNAVAILABLE = {
+    "error" => "verify_unavailable",
+    "detail" => "this session's worker predates Verify turns; restart this session to use Verify"
+  }.freeze
+
+  def VerifyAnchor.worker_unavailable?(features) = !features.nil? && !features.include?(VerifyAnchor::FEATURE)
 end

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.127.0"
+  VERSION = "0.129.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -118,6 +118,9 @@ module Samagotchi
       # Seconds GET /api/models waits for the hosts' lists before answering
       # with what it has (the listing goes on and fills the registry's cache).
       MODELS_WAIT_TIMEOUT = 4.0
+      # The one refusal for an update operation (an install, a workers
+      # restart, a chi web restart) asked while another one runs: 409 update_running.
+      UPDATE_RUNNING = "a chi update operation is already running; try again when it ends"
       EVENTS_POLL = 1.0
 
       # A callable the event loops ask whether the server still runs;
@@ -702,7 +705,7 @@ module Samagotchi
             false
           end
         end
-        return error_response(409, "update_running", "an update is already running") if already_running
+        return error_response(409, "update_running", UPDATE_RUNNING) if already_running
 
         @hub.publish_update(state: "running", rows: [], operation: "install", version: version)
         Thread.new { perform_update(version) }
@@ -774,7 +777,7 @@ module Samagotchi
             false
           end
         end
-        return error_response(409, "update_running", "a chi update operation is already running") if already_running
+        return error_response(409, "update_running", UPDATE_RUNNING) if already_running
 
         @hub.publish_update(state: "running", rows: [], operation: "workers")
         Thread.new { perform_worker_restarts }
@@ -834,7 +837,7 @@ module Samagotchi
           @update_running = true # held for good once restarting: the exec ends this process
           false
         end
-        return error_response(409, "update_running", "a chi update operation is running; restart chi web when it ends") if busy
+        return error_response(409, "update_running", UPDATE_RUNNING) if busy
 
         case @restart_web.call
         when true then return json_response(202, { state: "restarting" })
@@ -1721,8 +1724,7 @@ module Samagotchi
                            outcome.is_a?(WorkerLink::Leaving) || outcome.is_a?(WorkerLink::Stale) ||
                              outcome.is_a?(WorkerLink::Skew) ||
                              (outcome.is_a?(WorkerLink::Starting) && outcome.stuck)
-                         end,
-                         host: DEFAULT_HOST)
+                         end)
       end
 
       def stream_link_error(id, link)
@@ -1741,7 +1743,7 @@ module Samagotchi
       def stream_open_error(id, outcome)
         return error_response(503, "not_live", WorkerLink.unanswered(id)) if outcome.is_a?(BridgeClient::StreamOpen::Unreachable)
         return error_response(503, "not_live", WorkerLink.not_live(id)) if outcome.reason == :unknown_session
-        return error_response(502, "bridge_secret", BridgeSecret.refused(id)) if outcome.reason == :bridge_secret
+        return error_response(502, BridgeSecret::ERROR, BridgeSecret.refused(id)) if outcome.reason == :bridge_secret
 
         error_response(502, "bridge_error", outcome.detail || "the session's worker answered #{outcome.status}")
       end
@@ -1752,7 +1754,7 @@ module Samagotchi
       # @return [WorkerLink::Live, WorkerLink::None, WorkerLink::Stale]
       def worker_link(session_id)
         dir = @session_class.session_dir(session_id, state_dir: default_state_dir)
-        WorkerLink.resolve(dir, unlink: true, host: DEFAULT_HOST)
+        WorkerLink.resolve(dir, unlink: true)
       rescue StandardError
         WorkerLink::None.new
       end

data/lib/samagotchi/web/participant_review.rb

@@ -51,7 +51,8 @@ module Samagotchi
       #   current_turn, waiting_for_owner, queued: {mine, others}, last_event_id}
       def handle_review(req, id)
         session = @session_class.load(id, state_dir: default_state_dir)
-        mode = ParticipantMode.live(session, state_dir: default_state_dir).to_s
+        features = ParticipantMode.live_features(session, default_state_dir)
+        mode = ParticipantMode.of(session, features: features).to_s
         viewer = participant_viewer(req, session)
         live = bridge_get_json(id, "snapshot")
         turn_snapshot = live && live["snapshot"]
@@ -67,7 +68,8 @@ module Samagotchi
         status = Session::STATUS_IDLE if status == Session::STATUS_RUNNING && current.nil?
         json_response(200, {
           viewer: review_viewer(req, id, session: session, state: state, queued: queued, viewer: viewer, mode: mode),
-          session: { id: session.id, title: participant_title(session), status: status },
+          session: { id: session.id, title: participant_title(session), status: status,
+                     verify_unavailable: VerifyAnchor.worker_unavailable?(features) },
           subjects: review_subjects(session, viewer),
           participants: participant_names(id).map { |entry| entry.slice(:id, :name, :kind) },
           messages: with_reply_html(ParticipantView.messages(shown, viewer, automatic: automatic)),

data/lib/samagotchi/web/public/annotate_bar.js

@@ -32,6 +32,7 @@ import { actionEnabled, actionTitle, sameActions, selectionFields, splitInline }
 //   until its step closes)
 // @param onQuote (text) runs with the quote (and a preset's note) to append
 //   to the composer; the selection is cleared and the bar hidden first
+// @param disabledPreset (preset) → a reason to disable it, else null
 // @param actions () => the open session's annotation actions
 //   (annotate_actions.js annotationActions), read on every selection
 // @param running () => whether a turn runs (a send pill may wait for it)
@@ -56,7 +57,8 @@ import { actionEnabled, actionTitle, sameActions, selectionFields, splitInline }
 // @return {schedule(), hide(), el}; schedule() re-reads the selection on the
 //   next frame (call it on scroll)
 export function createAnnotateBar({
-  presets, canAnnotate, roots, isLive, onQuote, onPreset = () => {}, actions = () => [], running = () => false, onAction = () => {},
+  presets, canAnnotate, roots, isLive, onQuote, onPreset = () => {}, disabledPreset = () => null,
+  actions = () => [], running = () => false, onAction = () => {},
   dock = () => null, source: sourceOf = annotationSource, quote = quoteBlock, link = () => null, onLink = () => {},
   doc = globalThis.document, win = globalThis.window,
 }) {
@@ -80,6 +82,14 @@ export function createAnnotateBar({
     btn.title = text;
     bar.appendChild(btn);
   });
+  const presetButtons = [...bar.children].slice(1, presets.length + 1);
+  function markPresets() {
+    presetButtons.forEach((btn, i) => {
+      const reason = disabledPreset(presets[i]);
+      btn.disabled = !!reason;
+      btn.title = reason || presetParts(presets[i]).text;
+    });
+  }
   // The plugin pills: a separator, the inline ones, then ⋯ and the list
   // it opens. Redrawn only when the session's actions change.
   const group = doc.createElement("span");
@@ -175,6 +185,7 @@ export function createAnnotateBar({
     linkBtn.title = pendingLink?.title || "";
     const list = actions() || [];
     if (!sameActions(list, drawn)) drawActions(list);
+    markPresets();
     markActions();
     bar.hidden = false;
     if (touch?.matches) return placeDocked();
@@ -248,6 +259,7 @@ export function createAnnotateBar({
       return;
     }
     const preset = btn.dataset.index === undefined ? null : presets[Number(btn.dataset.index)];
+    if (btn.disabled || (preset && disabledPreset(preset))) return;
     const text = preset ? presetNote(pendingQuote, presetParts(preset).text) : pendingQuote;
     const fields = { ...pendingFields, source: pendingSource, range: pendingRange };
     win.getSelection()?.removeAllRanges();
@@ -256,7 +268,7 @@ export function createAnnotateBar({
     onQuote(text);
   });
 
-  return { schedule, hide, el: bar };
+  return { schedule, hide, refresh: markPresets, el: bar };
 }
 
 // A preset's button label and note: a text is both.

data/lib/samagotchi/web/public/app.js

@@ -59,12 +59,12 @@ import { createTaskStopper } from "./task_stop.js";
 import { createSystemOneWrongAction } from "./system_one_wrong.js";
 import { appendQuote } from "./annotations.js";
 import { applyComposerText, applyRowTemplate, fetchApply } from "./review_apply.js";
-import { nameVerdictCards } from "./verdict_card.js";
-import { freshURL, placeVerdictWithFresh, settleRunning } from "./verdict_fresh.js";
+import { CHECK_NOT_ON_PAGE, nameVerdictCards, ownerCheckHash } from "./verdict_card.js";
+import { freshURL, placeVerdictWithFresh, redrawFresh, settleRunning } from "./verdict_fresh.js";
 import { authorBadge, nameUnnamedBadges } from "./participant_names.js";
 import { parsePresets } from "./annotate_presets.js";
 import { createAnnotateBar } from "./annotate_bar.js";
-import { VERIFY_PRESET, withVerify } from "./verify_preset.js";
+import { VERIFY_PRESET, VERIFY_UNAVAILABLE, verifyWorkerUnavailable, withVerify } from "./verify_preset.js";
 import { actionLine, annotationActions, composerWithAction } from "./annotate_actions.js";
 import { copyText, installCopy } from "./copy.js";
 import { createQuestionCards } from "./question_cards.js";
@@ -235,6 +235,7 @@ const composeHintEl = $("#composeHint");
 
 let selected = null;
 let pendingVerifyAnchor = null;
+let annotateBar = null;
 // The session the composer's text was last written in ("" the start page,
 // undefined unknown): the composer is one for every session, and continue →
 // keeps only a draft of its own (fillOpener).
@@ -589,7 +590,13 @@ function copyUpdateCommand(command) {
 function followSelectedSession(sess) {
   current.owner = sess.owner || null;
   current.workerVersion = sess.worker_version || null;
+  const verifyWas = verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp);
   current.workerFeatures = Array.isArray(sess.worker_features) ? sess.worker_features : [];
+  current.bridgeUp = sess.bridge_up === true;
+  // The Verify gate flipped (a restart brought the feature): the cards' Verify fresh part follows.
+  if (verifyWas !== verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp)) {
+    redrawFresh(historyEl, verifyFreshState());
+  }
   const streaming = !!(streamControl && streamControl.live);
   if (!streaming) current.status = sess.status;
   updateInfoBar();
@@ -1344,18 +1351,27 @@ function placeVerdict(record) {
   placeVerdictWithFresh(historyEl, record, {
     who: badge ? badge.name : "You",
     author: record.by || null,
+    onMissingCheck: (missing) => {
+      const hash = ownerCheckHash(allSessions, selected, missing.check_turn_id);
+      if (hash) location.hash = hash;
+      else showToast(CHECK_NOT_ON_PAGE);
+    },
   }, verifyFreshState());
 }
 
 // The owner's Verify fresh on an unclear verdict's card (verdict_fresh.js):
 // always theirs to start; its running check links to the child's session.
+const verifyFreshErrors = {};
 function verifyFreshState() {
   const id = selected;
+  const unavailable = verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp);
   if (!Array.isArray(current.verifyFresh)) current.verifyFresh = [];
   return {
     verdicts: current.verdicts || [],
     running: current.verifyFresh,
-    canStart: !!id,
+    errors: verifyFreshErrors,
+    canStart: !!id && !unavailable,
+    unavailableReason: unavailable ? VERIFY_UNAVAILABLE : null,
     start: async (of) => {
       try {
         const body = await api(freshURL(id, of), { method: "POST", body: "{}" });
@@ -1421,6 +1437,7 @@ async function restartWorker() {
 // The session bar (info_bar_model.js sessionBar): its buttons, and the
 // info line rendered by info_bar.js.
 function updateInfoBar() {
+  annotateBar?.refresh();
   const { buttons, bar } = sessionBar({
     id: selected, state: current, sessions: allSessions, versions, cardTitle: (s) => lists.cardTitle(s),
     continuing: sessionActions.continuing, restarting: restartingIds, streaming: !!streamControl, running: liveTurn.running,
@@ -1574,6 +1591,7 @@ function workerGone(id, { opened = true } = {}) {
     if (!stopped) setLiveStatus("idle");
   }
   if (current.owner === "worker") current.owner = null;
+  current.bridgeUp = false;
   // Its card says "live" (the list's owner, or setLiveStatus's) until the
   // hub's event says otherwise: the worker is gone now, as far as this
   // tab can tell.
@@ -1956,8 +1974,10 @@ function fillComposer(text) {
   promptEl.scrollTop = promptEl.scrollHeight;
 }
 
-const annotateBar = createAnnotateBar({
+annotateBar = createAnnotateBar({
   presets: withVerify(parsePresets(document.body.dataset.annotatePresets)),
+  disabledPreset: (preset) => preset === VERIFY_PRESET
+    && verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp) ? VERIFY_UNAVAILABLE : null,
   canAnnotate: () => !!selected && current.owner !== "tui",
   roots: turnRoots,
   isLive: (root) => liveTurn.running && turnDom.containsLive(root),