samagotchi 0.145.0 → 0.147.0

data/lib/samagotchi/toolkit_suggest.rb

@@ -18,6 +18,9 @@ module Samagotchi
   class ToolkitSuggest
     FILE = "toolkit_suggestions.jsonl"
     QUESTION_ID = "toolkit"
+    # The defer sentinel: the choice "There is no task yet", asked as a
+    # criterion, never offered as a kit, and hidden from the web's picker.
+    UNDECIDED = "undecided"
     # Its saved asks' name (SystemOne::Runs).
     JUDGMENT = "toolkit.suggest"
     PROMPT_MAX = 1500
@@ -42,7 +45,7 @@ module Samagotchi
     # not the whole ask, and the ≥ 2 clause counts what is left.
     def self.candidates(kits, default_name:)
       kits.values.filter_map do |kit|
-        next if [default_name.to_s, Toolkit::REVIEW, "undecided"].include?(kit.name)
+        next if [default_name.to_s, Toolkit::REVIEW, UNDECIDED].include?(kit.name)
         next if kit.description.to_s.empty?
         next unless resolves?(kit.name, kits)
 
@@ -62,7 +65,7 @@ module Samagotchi
       candidates = candidates(kits, default_name: default.name)
       criteria = candidates.to_h { |kit| ["kit:#{kit.name}", "#{kit.name}: #{kit.description}"] }
       criteria["default"] = "none of the other toolkits fits: the user's everyday default"
-      criteria["undecided"] = "There is no task yet; defer this choice"
+      criteria[UNDECIDED] = "There is no task yet; defer this choice"
       question = SystemOne::Question.new(id: QUESTION_ID, type: :choice, instructions: INSTRUCTIONS, criteria: criteria)
       [question, { project: project.to_s, prompt: prompt.to_s[0, PROMPT_MAX] }]
     end
@@ -81,7 +84,7 @@ module Samagotchi
 
       messages = Array(session.messages)
       return true unless model_reply?(messages)
-      return false unless field(value(last_suggestion), :raw) == "undecided"
+      return false unless field(value(last_suggestion), :raw) == UNDECIDED
 
       current_turn_number = turn_number(messages)
       current_turn_number <= defer_turns.to_i && conversation_chars(messages) / CHARS_PER_TOKEN < defer_tokens.to_i
@@ -139,7 +142,7 @@ module Samagotchi
       decided = raw == "default" || (candidate && confidence && confidence >= threshold.to_f)
       would = if answer.nil?
                 "no_judgment"
-              elsif raw == "undecided"
+              elsif raw == UNDECIDED
                 "defer"
               elsif raw == "default"
                 "default"

data/lib/samagotchi/tools/delegate.rb

@@ -5,6 +5,7 @@ require_relative "../session"
 require_relative "../config"
 require_relative "../model_profile"
 require_relative "../memory_paths"
+require_relative "../guardrails/context"
 require_relative "peers"
 require_relative "delegate_wait"
 require_relative "../child_reports"
@@ -27,6 +28,9 @@ module Samagotchi
       NAME = "delegate"
       MAX_CHILDREN_KEY = "session.max_children"
       MAX_CHILDREN_DEFAULT = 4
+      # A path in a task: absolute, ~/ or ../, not glued to a word (a URL's
+      # /api is not one) and stopping at quotes, backticks or punctuation.
+      PATH_TOKEN = %r{(?<![\w./~-])(?:~/|\.\./|/(?!/))[^\s`'"<>()\[\]{},;&|]*}
       # A child spawned this many seconds ago counts as running even before
       # its worker holds the owner lock: two delegate calls in one model
       # message come milliseconds apart, and the first child's worker is
@@ -60,19 +64,19 @@ module Samagotchi
 
         cwd = cwd.to_s.strip
         toolkit = toolkit.to_s.strip
-        child_id, warning = if session.to_s.strip.empty?
-                              start_child(task, parent: parent, model: model, cwd: cwd, toolkit: toolkit, state_dir: sd,
-                                                peers: peers)
-                            elsif !cwd.empty?
-                              "Error: cwd starts a new child; a follow-up with session keeps the child's folder"
-                            elsif !toolkit.empty?
-                              "Error: toolkit starts a new child; a follow-up keeps the child's toolkit"
-                            else
-                              follow_up(task, session: session.to_s.strip, parent: parent, state_dir: sd)
-                            end
+        child_id, warnings = if session.to_s.strip.empty?
+                               start_child(task, parent: parent, model: model, cwd: cwd, toolkit: toolkit, state_dir: sd,
+                                                 peers: peers)
+                             elsif !cwd.empty?
+                               "Error: cwd starts a new child; a follow-up with session keeps the child's folder"
+                             elsif !toolkit.empty?
+                               "Error: toolkit starts a new child; a follow-up keeps the child's toolkit"
+                             else
+                               follow_up(task, session: session.to_s.strip, parent: parent, state_dir: sd)
+                             end
         return child_id if child_id.start_with?("Error:")
 
-        note = warning ? "Warning: #{warning}\n" : ""
+        note = Array(warnings).map { |warning| "Warning: #{warning}\n" }.join
         if wait
           result = DelegateWait.call(child_id, peers: peers, timeout: timeout)
           return RefText.wrap(note + result, result.respond_to?(:ref_path) ? result.ref_path : nil)
@@ -114,7 +118,8 @@ module Samagotchi
       private_class_method :full_hint
 
       # @param toolkit [String] a kit's name, "" for config's toolkit.child
-      # @return [String] the new child's id, or an Error: line
+      # @return [String, Array<String>] the new child's id, or an Error: line,
+      #   and its warnings (each without the "Warning: " prefix)
       def self.start_child(task, parent:, model:, cwd:, toolkit:, state_dir:, peers:)
         if parent.parent_id
           return "Error: this session is a delegate of #{parent.parent_id}; delegated sessions don't delegate further"
@@ -142,10 +147,80 @@ module Samagotchi
                                              model_name: child_model(model, parent), memories: CHILD_MEMORIES,
                                              parent_id: parent.id, delegate: true, setup: setup, state_dir: state_dir)
         DelegateWait.mark_started(parent.id, child, state_dir: state_dir)
-        [child.id, child.model_warning]
+        # The line for a task that names a worktree while the child runs in
+        # the parent's folder (no cwd: given): the child still starts.
+        [child.id, [child.model_warning, other_checkout(task, folder, parent: parent, child_id: child.id,
+                                                        no_cwd: cwd.empty?)].compact]
       end
       private_class_method :start_child
 
+      # A new child with no cwd: its task may name another checkout of this
+      # repository (a worktree the parent meant to pass as cwd:), which makes
+      # every write there an ask for the user (child-boundary). One warning
+      # line, however many are named; nil when the task names none, or names
+      # only the checkout holding the child's folder (or a subfolder of it).
+      # Never raises: a started child must not come back as an Error:.
+      # @return [String, nil]
+      def self.other_checkout(task, folder, parent:, child_id:, no_cwd:)
+        return nil unless no_cwd
+
+        checkout = foreign_checkout(task, folder)
+        return nil unless checkout
+
+        Log.info(:worker, "delegate_other_checkout", parent: parent.id[0, 8])
+        "this child runs in #{folder}, but its task names #{checkout}. If it should work there, stop it " \
+          "(chi sessions stop #{child_id}) and call delegate again without session, with cwd: #{checkout}."
+      rescue StandardError
+        nil
+      end
+      private_class_method :other_checkout
+
+      # The checkout of +folder+'s repository that the task names and that is
+      # not the one holding +folder+: the first path token in the task that
+      # belongs to one (the deepest containing it), else nil. Reads files
+      # only, no git process, so a spec stubbing Process.spawn is unaffected.
+      # @return [String, nil] an absolute checkout folder
+      def self.foreign_checkout(task, folder)
+        common = MemoryPaths.common_git_dir(folder)
+        return nil unless common
+
+        checkouts = Guardrails::GitInfo.checkouts(common).map { |checkout| File.realpath(checkout) }
+        own = deepest_checkout(File.realpath(folder), checkouts)
+        task.to_s.scan(PATH_TOKEN) do |token|
+          path = existing_ancestor(File.expand_path(token.sub(/[.:!?]+\z/, ""), folder))
+          next if path.nil?
+
+          found = deepest_checkout(path, checkouts)
+          return found if found && found != own
+        end
+        nil
+      end
+      private_class_method :foreign_checkout
+
+      # The checkout containing +path+, matched by whole components (so
+      # /x/app is not found in /x/app-fix): the deepest, so a nested worktree's
+      # path belongs to that worktree, not to main; nil when none does.
+      def self.deepest_checkout(path, checkouts)
+        checkouts.select { |checkout| within?(path, checkout) }.max_by { |checkout| checkout.count("/") }
+      end
+      private_class_method :deepest_checkout
+
+      # +path+'s longest ancestor that exists, realpathed (a worktree not made
+      # yet still points at its parent folder); nil when nothing above it does.
+      def self.existing_ancestor(path)
+        dir = path
+        until File.exist?(dir)
+          parent = File.dirname(dir)
+          return nil if parent == dir
+
+          dir = parent
+        end
+        File.realpath(dir)
+      rescue StandardError
+        nil
+      end
+      private_class_method :existing_ancestor
+
       # The Error: line for a toolkit name the parent doesn't know
       # (Peers#toolkit_names: its built-in, config and plugin kits), nil
       # when it knows it, none was given, or the peers can't tell (a bare

data/lib/samagotchi/tools/memory.rb

@@ -126,8 +126,7 @@ module Samagotchi
       # @param env [Hash] the XDG env the memories dir resolves from
       def self.scoped_index(scope, env: ENV)
         dir = memories_dir(scope, env: env)
-        index_path = File.join(dir, "#{MEMORY_INDEX}.md")
-        return File.read(index_path, encoding: "UTF-8") if File.exist?(index_path)
+        return read_text(File.join(dir, "#{MEMORY_INDEX}.md")) if File.file?(File.join(dir, "#{MEMORY_INDEX}.md"))
 
         files = Dir.glob(File.join(dir, "*.md")).sort
         return "No memories stored yet." if files.empty?
@@ -135,6 +134,17 @@ module Samagotchi
         "Stored memories (no index yet):\n" + files.map { |f| File.basename(f, ".md") }.join("\n")
       end
 
+      # A text file from a memories dir, safe to match: a hand-edited index
+      # can hold a byte that isn't valid UTF-8, and a regex on it raises.
+      def self.read_text(path)
+        return "" unless File.file?(path)
+
+        text = File.read(path, encoding: "UTF-8")
+        text.valid_encoding? ? text : text.scrub
+      rescue StandardError
+        ""
+      end
+
       def self.memory_path(entry_name, scope)
         File.join(memories_dir(scope), "#{entry_name}.md")
       end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -1018,7 +1018,7 @@ module Samagotchi
       def handle_info(req)
         return participant_info unless principal(req).owner?
 
-        chi_state = @hub&.chi_state || { version: Samagotchi::VERSION, installed: nil, available: nil, update_blocked: nil, auto: "off", restart: "idle" }
+        chi_state = @hub&.chi_state || { version: Samagotchi::VERSION, installed: nil, available: nil, update_blocked: nil, auto: "off", restart: "idle", auto_offers: nil }
         json_response(200, { app: "chi-web", **chi_state, pid: Process.pid,
                              cwd: Dir.pwd, start_dir: start_dir, features: INFO_FEATURES, lan: @lan && @lan[:ip],
                              proxy: @public_url && { identity_header: @public_url.identity_header } })
@@ -1099,7 +1099,7 @@ module Samagotchi
 
       # Kits the web never offers: the participants' boundary, a delegate
       # child's, and ToolkitSuggest's defer sentinel.
-      PICKER_HIDDEN_KITS = [Toolkit::REVIEW, Toolkit::CHILD, "undecided"].freeze
+      PICKER_HIDDEN_KITS = [Toolkit::REVIEW, Toolkit::CHILD, ToolkitSuggest::UNDECIDED].freeze
 
       # The start page's toolkit picker: {default:, suggest:, kits: [{name,
       # description?}]}. Built-in and config kits only (a bundle's load in

data/lib/samagotchi/web/auto_update.rb

@@ -3,6 +3,7 @@
 require "rubygems/version"
 require "time"
 require_relative "../config"
+require_relative "../installed_versions"
 require_relative "../log"
 require_relative "../version"
 require_relative "auto_update_record"
@@ -37,6 +38,17 @@ module Samagotchi
     # A preflight that fails leaves chi web as it is and says so.
     # update.restart: never stops after the install.
     #
+    # A newer chi installed some other way (a terminal's `chi update`, inside
+    # update.min_age_hours or not) is adopted: once it has settled and the
+    # gate is open, it gets a run from step 1 on. One run per version here
+    # too, so a restart that didn't take isn't tried again.
+    #
+    # The page offers no restart buttons for a run that will do them itself.
+    # It offers them again when this says so (SessionHub#auto_offer_restart):
+    # a run on record for the version ended with chi web still older, or
+    # something held it for HELD_FOR, a forgotten question or a long turn.
+    # The trying goes on behind that offer.
+    #
     # The run's record (AutoUpdateRecord) lives in update_check.json
     # (UpdateCheck#save_auto), so a chi web restart finds it. See
     # docs/architecture.md.
@@ -56,6 +68,13 @@ module Samagotchi
       OPEN_PHASES = %w[installed workers web].freeze
       # The phase after "chi updated" while workers are left.
       RETRYING = "retrying"
+      # A newer chi seen installed is adopted only this long after: `chi update`
+      # installs the gem first and merges the bundles after, with no lock or
+      # marker to look at. In practice the next POLL.
+      SETTLE = 60
+      # How long a newer installed chi may wait for its restart before the page
+      # offers the buttons again.
+      HELD_FOR = 3600
       # How long stop waits for the thread: long enough for a preflight
       # (Server::PREFLIGHT_TIMEOUT, 20 s; a healthy one takes about a
       # second) to end on its own, so a stop never abandons one mid-way.
@@ -84,6 +103,7 @@ module Samagotchi
         @wakeup = Queue.new
         @thread = nil
         @stopped = false
+        @seen = nil
       end
 
       def start
@@ -108,17 +128,17 @@ module Samagotchi
       def step
         return unless @auto == "install"
 
+        note_installed
         record = @check.auto_state
         return carry_on(record) if record && OPEN_PHASES.include?(record.phase)
 
         retry_left(record) if record&.phase == RETRYING
+        return if @ops.blocked_reason || @ops.running? || busy_turn?
 
         version = @check.available
-        return unless version
-        return if @check.auto_failed?(version) || tried?(version)
-        return if @ops.blocked_reason || @ops.running? || busy_turn?
+        return install(version) if version && !@check.auto_failed?(version) && !tried?(version)
 
-        install(version)
+        adopt_installed
       end
 
       private
@@ -158,6 +178,37 @@ module Samagotchi
         end
       end
 
+      # What is installed, ahead of every gate: since when a newer chi is, and
+      # whether the page should offer the restarts for it. A chi web restart
+      # starts the clock over, and finds a closed run's offer again here.
+      def note_installed
+        installed = @hub.refresh_installed
+        return @seen = nil unless InstalledVersions.newer?(installed)
+
+        now = @clock.call
+        @seen = [installed, now] unless @seen&.first == installed
+        @hub.auto_offer_restart(installed) if closed_run?(installed) || now - @seen.last >= HELD_FOR
+      end
+
+      # A run on record for +version+ that is over, with chi web still older.
+      def closed_run?(version)
+        record = @check.auto_state
+        !record.nil? && record.version == version && !OPEN_PHASES.include?(record.phase)
+      end
+
+      # A newer chi this didn't install, settled: a run of its own from here.
+      # The terminal's table already told what `chi update` kept.
+      def adopt_installed
+        return unless @restart == "idle" && @seen
+
+        installed, seen_at = @seen
+        now = @clock.call
+        return if tried?(installed) || now - seen_at < SETTLE
+
+        Log.info(:web, "auto_update_adopted", version: installed, from: VERSION)
+        carry_on(save(AutoUpdateRecord.new(version: installed, from: VERSION, at: now.iso8601, phase: "installed")))
+      end
+
       def install(version)
         Log.info(:web, "auto_update_start", version: version, from: VERSION)
         result = @ops.install(version, wait: true, auto: true)
@@ -187,7 +238,9 @@ module Samagotchi
       # The next step of a run on record.
       def carry_on(record)
         case record.phase
-        when "installed", "workers" then workers_then_web(record)
+        when "installed", "workers"
+          # Restarted by hand on the way (the page's offer): nothing left to exec.
+          InstalledVersions.newer?(record.version) ? workers_then_web(record) : finish(record)
         when "web" then finish(record)
         end
       end
@@ -260,6 +313,7 @@ module Samagotchi
       def restart_failed(record, detail, event)
         Log.warn(:web, event, version: record.version, detail: detail)
         save(record.with(phase: "failed", detail: detail, pushed: true))
+        @hub.auto_offer_restart(record.version)
         @hub.publish_notice(kind: "restart_failed", version: record.version, detail: detail)
       end
 
@@ -307,6 +361,7 @@ module Samagotchi
         Log.warn(:web, "auto_update_failed_install", version: record.version, detail: detail)
         gem_installed = rows.any? { |candidate| candidate["component"] == "chi (gem)" && !candidate["failed"] }
         @check.save_auto(record.with(phase: "failed", detail: detail, pushed: true), failed: record.version)
+        @hub.auto_offer_restart(record.version)
         @hub.publish_notice(kind: "failed", version: record.version, detail: detail.empty? ? nil : detail,
                             installed: gem_installed)
       end

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

@@ -95,7 +95,7 @@ import { waitingOn } from "./notify.js";
 import { applySessionEvent, sortedByUpdated } from "./sessions_list.js";
 import { createNotifications } from "./notifications.js";
 import { renameShown, tabTitle, topBarTitle } from "./session_title.js";
-import { mergeVersionState, restartConfirmText, versionNotice } from "./update_notice.js";
+import { mergeVersionState, restartConfirmText, updateFrameToast, versionNotice } from "./update_notice.js";
 import {
   appendAboveLiveTiming, mergeTiming, normalizeTiming,
 } from "./timing.js";
@@ -433,6 +433,8 @@ const questionCards = createQuestionCards({
   renderMarkdown,
   linkRefs: linkRefsIn,
   pairRefs: pairRefsIn,
+  // The bar's chip reads questionCards.pendingQuestion() (sessionWaits).
+  onPending: () => store.touch("infoBar"),
 });
 // The history's bubbles (bubbles.js): output, end lines, every client's
 // prompts, the recap, warnings and notices, command and note bubbles.
@@ -583,7 +585,7 @@ function noticeVersions(data) {
   const notice = versionNotice({ loaded: document.body.dataset.version, served: versions.served,
                                  installed: versions.installed, available: versions.available,
                                  updateBlocked: versions.updateBlocked, auto: versions.auto, restart: versions.restart,
-                                 autoInstall: versions.autoInstall, shown: versionNoticesShown });
+                                 autoOffers: versions.autoOffers, shown: versionNoticesShown });
   store.touch("infoBar"); // the worker badge compares with the newest installed
   if (!notice) return;
   versionNoticesShown.add(notice.key);
@@ -612,20 +614,9 @@ function noticeVersions(data) {
 function updateFrame(data, { snapshot = false } = {}) {
   const wasOpen = updateSheet.isOpen();
   if (!updateSheet.receive(data)) return;
-  // Every install frame, not only the done one: the hub's `chi` frame with
-  // the new installed version comes before it, and an automatic run's
-  // running frame is what keeps that from offering the Restart toast.
-  if (data.operation === "install") {
-    noticeVersions({ ...(data.state === "done" && data.version ? { installed: data.version } : {}), chi_update: data });
-  }
-  const label = `${data.auto ? "Automatic " : ""}${data.operation === "install" ? "chi update" : "worker restart"}`
-    .replace(/^./, (c) => c.toUpperCase());
-  if (!wasOpen && data.state === "running") {
-    showToast(`${label} in progress`, { label: "View", run: () => updateSheet.view() }, { sticky: true });
-  } else if (!snapshot && !wasOpen && ["done", "failed"].includes(data.state)
-    && !(data.operation === "install" && data.state === "done")) {
-    showToast(`${label} ${data.state}`, { label: "View", run: () => updateSheet.view() }, { sticky: true });
-  }
+  if (data.operation === "install" && data.state === "done" && data.version) noticeVersions({ installed: data.version });
+  const text = updateFrameToast(data, { wasOpen, snapshot });
+  if (text) showToast(text, { label: "View", run: () => updateSheet.view() }, { sticky: true });
 }
 
 function copyUpdateCommand(command) {
@@ -1508,9 +1499,11 @@ async function restartWorker() {
 
 // The session bar (info_bar_model.js sessionBar): its buttons, and the
 // info line rendered by info_bar.js.
-// The open session waits on the user: its summary says so, or its card is up.
+// The open session waits on the user: its card is up, or its summary says so
+// (not for a question answered here: the summary is a refresh behind).
 function sessionWaits() {
-  return !!(waitingOn(store.sessions.find((s) => s.id === store.selected)) || questionCards.pendingQuestion());
+  const summary = waitingOn(store.sessions.find((s) => s.id === store.selected));
+  return !!((summary && !questionCards.isResolved(summary.id)) || questionCards.pendingQuestion());
 }
 function updateInfoBar() {
   annotateBar?.refresh();

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

@@ -18,6 +18,7 @@
 // blank the page.
 
 import { quoteBlock } from "./annotations.js";
+import { isParticipantAuthor } from "./participant_model.js";
 
 // Where a node on the participant page came from: { kind, root, … } where
 // root is the element a selection is clipped to, or null.
@@ -69,7 +70,7 @@ export function participantQuote(text, source) {
 // participant route's: mine, author, author_name, automatic).
 export function messageAuthorData(message) {
   if (message?.mine) return { by: "me" };
-  if (message?.author) return { by: "participant", name: message.author_name || "" };
+  if (isParticipantAuthor(message?.author)) return { by: "participant", name: message.author_name || "" };
   if (message?.automatic) return { by: "automatic" };
   return { by: "owner" };
 }

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

@@ -41,13 +41,18 @@ import { plainText } from "./plain_line.js";
 //   own text; markdown_place.js pairRefsIn)
 // @param api {sendAnswer, dismissQuestion, sendCommand} (data.js)
 // @param doc the page's document
+// @param onPending (pending|null) called whenever the open question changes:
+//   the page touches the redraws that read pendingQuestion() (the session
+//   bar's waiting chip, docs/internals/web-frontend.md write -> redraw)
 // @return {renderQuestion(pq, {said}), resolveQuestion(id, opts), removeQuestion(),
 //   questionCard() (the live card or null), pendingQuestion() (or null),
+//   isResolved(id) (this page already saw that question answered),
 //   renderContinue(offer), resolveContinue(data), forgetContinue()}
 export function createQuestionCards({
   sessionId, clientId, place, isNearBottom, scrollToEnd, removeHintIfEmpty, askingText = () => "",
   renderMarkdown = () => Promise.resolve(null), linkRefs = () => {}, pairRefs = () => {},
   api = { sendAnswer, dismissQuestion, sendCommand }, doc = globalThis.document,
+  onPending = () => {},
 }) {
   // Live ask_user_question card, keyed by pending question id. Re-rendered from
   // pending_question on session select so a reload mid-question restores it.
@@ -57,6 +62,16 @@ export function createQuestionCards({
   let continueEl = null;
   // card → the reply that asked it, drawn under the summary once resolved.
   const saidOf = new WeakMap();
+  // The question last answered here: a session summary fetched earlier still
+  // names it as pending until the next refresh (isResolved).
+  let resolvedId = null;
+
+  // The one way the open question changes: +onPending+ is the page's hook for
+  // the redraws that read it (the session bar's waiting chip).
+  function setPending(next) {
+    pending = next;
+    onPending(pending);
+  }
 
   // +said+: the asking reply when the caller knows it (a reloaded card: its
   // step's text, "" for none); else the running turn's (askingText).
@@ -65,8 +80,8 @@ export function createQuestionCards({
     if (action === "same") return;
     // A resolved card stays where it was; only a pending one is replaced.
     if (action === "keep") questionEl = null;
-    else removeQuestionCard();
-    pending = pq;
+    else replaceQuestionCard();
+    setPending(pq);
     removeHintIfEmpty();
 
     const approval = approvalView(pq);
@@ -424,7 +439,7 @@ export function createQuestionCards({
   // The parent relayed the open question, or no longer does (question_relay).
   function markRelayed(id, relayedTo) {
     if (!questionEl || !pending || String(pending.id) !== String(id)) return;
-    pending = { ...pending, relayed_to: relayedTo || null };
+    setPending({ ...pending, relayed_to: relayedTo || null });
     questionEl.querySelector(".question-relayed")?.replaceWith(renderRelayedTo(pending));
   }
 
@@ -491,7 +506,8 @@ export function createQuestionCards({
     if (!questionEl.dataset.toggled) questionEl.open = false;
     // After the collapse: a card left open by hand renders at once.
     if (full) renderSaidOnOpen(questionEl, full, asked, refs);
-    pending = null;
+    resolvedId = pending.id;
+    setPending(null);
   }
 
   // The body's copy as markdown, from the card's first open on (a reload
@@ -546,11 +562,18 @@ export function createQuestionCards({
   }
 
   function removeQuestionCard() {
-    if (questionEl) {
-      questionEl.remove();
-      questionEl = null;
-    }
-    pending = null;
+    replaceQuestionCard();
+    setPending(null);
+  }
+
+  // The live card taken off the history because a new one takes its place:
+  // the question itself changes in the same step, so the hook is not touched
+  // for the in-between null.
+  function replaceQuestionCard() {
+    if (!questionEl) return;
+
+    questionEl.remove();
+    questionEl = null;
   }
 
   // ── continue card ──────────────────────────────────────────────────────────
@@ -653,6 +676,7 @@ export function createQuestionCards({
     removeQuestion: removeQuestionCard,
     questionCard: () => questionEl,
     pendingQuestion: () => pending,
+    isResolved: (id) => resolvedId !== null && String(resolvedId) === String(id),
     renderContinue: renderContinueCard,
     resolveContinue: resolveContinueCard,
     // The running turn's DOM was reset: a later offer draws a new card.

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

@@ -30,6 +30,7 @@ import { bubbleCopyText } from "./copy.js";
 import { foldLabel, keepRowInView, lineCount, readFolded, writeFold } from "./answer_fold.js";
 import { clip } from "./format.js";
 import { NOTE_BOUNDARY } from "./turn_range.js";
+import { workerPredates } from "./worker_features.js";
 import { SWAPPED_CLASS, VIEW_CLASS, stepVersion, switcherTemplate, viewOf } from "./revise_switch.js";
 
 // The classes and attributes this module puts on the history.
@@ -113,12 +114,12 @@ export function versionChipText(count, at = count - 1) {
 // the worker predates Revise turns).
 export const REVISE_UNAVAILABLE = "restart this session to use Revise";
 
-// The feature gate (app.js featureGates): a live worker without the
-// "revise" feature predates Revise turns (chi web would answer 409
-// revise_unavailable). A worker that isn't up isn't asked: the send wakes a
-// new one, which has it (as Verify's gate, verify_preset.js).
+// The feature gate (app.js featureGates): a live worker without the "revise"
+// feature predates Revise turns (chi web would answer 409 revise_unavailable).
+// A worker that isn't up isn't asked: the send wakes a new one, which has it
+// (worker_features.js's rule, the same as Verify's gate).
 export function reviseWorkerUnavailable(workerFeatures, bridgeUp) {
-  return bridgeUp === true && Array.isArray(workerFeatures) && !workerFeatures.includes("revise");
+  return workerPredates(workerFeatures, bridgeUp, "revise");
 }
 export function reviseChipText(label, { unavailable = false } = {}) {
   if (unavailable) return `Revise: ${REVISE_UNAVAILABLE}`;

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

@@ -17,12 +17,7 @@ export function mergeVersionState(current = {}, frame = {}) {
   if (has(frame, "update_blocked")) next.updateBlocked = known(frame.update_blocked) ? frame.update_blocked : null;
   if (has(frame, "auto")) next.auto = frame.auto === "install" ? "install" : "off";
   if (has(frame, "restart")) next.restart = frame.restart === "never" ? "never" : "idle";
-  // The last install's chi_update state (a snapshot's, or a frame's): the
-  // version an automatic one installs, while it hasn't failed.
-  const run = frame.chi_update;
-  if (run && run.operation === "install" && known(run.version)) {
-    next.autoInstall = run.auto === true && run.state !== "failed" ? run.version : null;
-  }
+  if (has(frame, "auto_offers")) next.autoOffers = known(frame.auto_offers) ? frame.auto_offers : null;
   return next;
 }
 
@@ -53,22 +48,23 @@ export function newerVersion(a, b) {
 // The toast for the versions as the page knows them, or null:
 // - loaded ≠ served: chi web restarted on another version; reload the page;
 // - installed newer than served: chi web runs an older chi than installed;
-//   restart its workers or chi web; not for the version an automatic install
-//   (+autoInstall+) brought with update.restart: idle, whose run restarts
-//   them by itself (and pushes how it went);
+//   restart its workers or chi web; not with update.auto: install and
+//   update.restart: idle (and not blocked), where chi web restarts them by
+//   itself and pushes how it went, however that chi got installed, unless
+//   chi web says it won't or has been held for long (+autoOffers+);
 // - available newer than served: install it, unless the install is blocked;
 //   with update.auto: install (and not blocked) chi web installs it by itself
 //   once no turn runs: the notice says so, with no Update button.
 // Each has a key; one in +shown+ (a Set: what this tab already showed, as
 // every reconnect's snapshot says it again) is not shown twice.
 // @return {{key, text, reload: boolean} | null}
-export function versionNotice({ loaded, served, installed, available, updateBlocked, auto, restart, autoInstall,
+export function versionNotice({ loaded, served, installed, available, updateBlocked, auto, restart, autoOffers,
   shown = new Set() } = {}) {
   let notice = null;
   if (known(loaded) && known(served) && loaded !== served) {
     notice = { key: `reload:${served}`, text: `chi was updated to ${served}`, reload: true };
   } else if (newerVersion(installed, served)) {
-    const restartsByItself = auto === "install" && restart !== "never" && autoInstall === installed;
+    const restartsByItself = auto === "install" && restart !== "never" && !updateBlocked && autoOffers !== installed;
     if (!restartsByItself) {
       notice = {
         key: `installed:${installed}`,
@@ -101,6 +97,21 @@ export function versionNotice({ loaded, served, installed, available, updateBloc
   return notice && !shown.has(notice.key) ? notice : null;
 }
 
+// The toast's words for an update operation's frame, or null: what runs and how
+// it ended, for a tab whose sheet isn't open. An automatic run's worker passes
+// say something only when one fails (the run ends in the Reload toast); a done
+// install leaves it to the version toast; a snapshot repeats no ending.
+export function updateFrameToast(data, { wasOpen = false, snapshot = false } = {}) {
+  if (wasOpen) return null;
+  if (data.auto && data.operation === "workers" && data.state !== "failed") return null;
+  const label = `${data.auto ? "Automatic " : ""}${data.operation === "install" ? "chi update" : "worker restart"}`
+    .replace(/^./, (c) => c.toUpperCase());
+  if (data.state === "running") return `${label} in progress`;
+  if (snapshot || !["done", "failed"].includes(data.state)) return null;
+  if (data.operation === "install" && data.state === "done") return null;
+  return `${label} ${data.state}`;
+}
+
 // The info bar's badge for the open session's worker when it runs an older
 // chi than the newest installed (or than chi web, while that is unknown),
 // else null. A worker with the "restart" feature offers Restart; an older