samagotchi 0.146.0 → 0.147.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 701bfb63903962a149abf5d17f39be6c043141e5e1b9ea952e7ba27b77ebe3d8
-  data.tar.gz: 7be23545775dc31bba230e8dfde6c896def7530d032cc8ae7f79d2a9b91d7782
+  metadata.gz: 29546fb5487086302ed4d68c168fa9e7f4f576bee252e59cfdaf08a4e74081b4
+  data.tar.gz: 3c05877e89bccf719dbdf8f4287c8343222f897484c2f22a4c3245bdc92a2af1
 SHA512:
-  metadata.gz: 8e4a8bbbfa0398b816a6dd266a6b127f507e6329feaf2b5f37283f2eef76344a334e2bf60409978fab45ab714c56ca1c9c44754174222238d930845bc0f5d929
-  data.tar.gz: 139f5254bb1dbeec07cbdf6cb0033cdb34ce5eae967585a9ab9a843fb961528e0d16b77d562668789646b38b16eaca42e28f2338d49f4ebe47b42a58be6f9597
+  metadata.gz: 953166016279e2b81ebe64c9642df2a245cc3d7fe4520850bf4023557b5d1b7fd620589fd7c49df66d458e59eeae32dffb3020e6286ea8be85edf2710c2bd7d4
+  data.tar.gz: 6c01b8ac5e044770f34e4fd5057915116e8b56b81a6f505fac3259449911a02b091262aad2554417ebf0493068ace77b1636d3fb8187769225268d12540c5354

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and commands may change between minor versions. How releases are made:
 [docs/releasing.md](docs/releasing.md).
 ## [Unreleased]
 
+## [0.147.0] - 2026-11-03
+
+### Changed
+
+- With `update.auto: install` a newer chi installed some other way, such as `chi update` in a terminal, now gets the
+  same unattended restarts as one chi web installed itself: idle workers and chi web move onto it within about 10
+  minutes once no turn runs, and the phone hears "chi updated to X". The page offers no **Restart** buttons meanwhile,
+  unless the restart failed or has waited an hour; `update.restart: never` keeps them.
+  [docs/configuration.md](docs/configuration.md#unattended-updates-updateauto)
+
+### Fixed
+
+- An automatic update's sheet no longer offers **Restart workers** and **Restart chi web** beside a run already doing
+  both, and its worker restarts no longer stack sticky toasts unless one fails.
+
 ## [0.146.0] - 2026-11-03
 
 ### Added
@@ -5580,7 +5595,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.146.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.147.0...HEAD
+[0.147.0]: https://github.com/dm1try/samagotchi/compare/v0.146.0...v0.147.0
 [0.146.0]: https://github.com/dm1try/samagotchi/compare/v0.145.0...v0.146.0
 [0.145.0]: https://github.com/dm1try/samagotchi/compare/v0.144.0...v0.145.0
 [0.144.0]: https://github.com/dm1try/samagotchi/compare/v0.143.0...v0.144.0

data/docs/architecture.md

@@ -335,9 +335,10 @@ reload in a toast, since an open tab keeps its old JS across a `chi web` upgrade
 `installed`, the newest chi on this machine (`InstalledVersions`: the highest `samagotchi-<v>.gemspec`
 in RubyGems' specification dirs, or a checkout's `version.rb` on disk; looked at again on each full
 probe, every 10 s). A `chi` frame and the `GET /api/events` snapshot carry the full state
-`{version, installed, available, update_blocked, auto, restart}` (`auto`: `update.auto`, `off` or `install`, which the page's
-"available" wording follows; `restart`: `update.restart`, with which the page offers no Restart toast for the
-version an automatic install's frames name unless it is `never` or the run failed: that run restarts by itself); `/api/info` and the session-command wake response carry the same fields. `SessionHub#update_available` publishes the checker result under the hub's
+`{version, installed, available, update_blocked, auto, restart, auto_offers}` (`auto`: `update.auto`, `off` or `install`, which the page's
+"available" wording follows; `restart`: `update.restart`; `auto_offers`: the version AutoUpdate says the page should offer
+the restarts for. With `auto: install`, `restart: idle` and no block the page offers no Restart toast for a newer installed
+chi, however it got installed, unless `auto_offers` names it); `/api/info` and the session-command wake response carry the same fields. `SessionHub#update_available` publishes the checker result under the hub's
 Monitor, but fetching never holds it.
 
 `Web::UpdateCheck` runs its own thread beside the hub. When `update.notify: on` (the default) or
@@ -385,7 +386,14 @@ is `update.auto: install`. Every 5 minutes (the first step 60 s after start) it
 and installs it through `UpdateOps#install(wait: true, auto: true)` when the install isn't blocked, no operation
 runs, no hub summary has `status: running` or a `pending_question`, and the version isn't in `auto_failed` or
 already in the `auto` record (one automatic try per version). Its frames carry `auto: true` (the page: "Automatic
-chi update in progress", "(automatic)" in the sheet's title). Its record is `update_check.json`'s `auto`:
+chi update in progress", "(automatic)" in the sheet's title, no restart buttons in the sheet, no toast for a worker pass
+unless it fails). A newer chi installed some other way (`AutoUpdate#adopt_installed`: `update.restart: idle`, the same gate, no
+available release to install first, none on record for that version) is **adopted** once seen for `SETTLE` (60 s, in
+practice the next step, as `chi update` merges the bundles after installing the gem and leaves no lock to look at): its
+record starts at `phase: installed` and the run goes on as below. Ahead of every gate each step calls
+`SessionHub#auto_offer_restart` (`auto_offers`, in memory) when a run on record for the newest installed chi is closed with
+this chi web still older, or that chi has waited `HELD_FOR` (1 h): the trying goes on, and the page has its buttons back;
+`restart_failed` and a failed install call it at once. Its record is `update_check.json`'s `auto`:
 `{version, from, at, kept, phase: installed|workers|web|retrying|done|failed, workers: {restarted, left}, detail, pushed}`,
 in Ruby the value object `Web::AutoUpdateRecord`, which owns that shape (`from_h`, `to_store`).
 With `update.restart: never` the run ends at the install (`chi_notice` `installed`). With `idle` it goes on
@@ -395,7 +403,8 @@ the worker's own atomic refusal still applies); then, with no
 turn running, `Server.restart_preflight` (the restart's command with `--version`, 20 s, killed on a timeout; it must
 print a chi at least the release) and, if it passes, the record's `phase: web` is written **before**
 `UpdateOps#restart_web`. A failed preflight, or a refused restart, publishes `restart_failed` and ends the run
-(`failed`). `AutoUpdate#stop` waits `STOP_WAIT` (25 s, longer than the preflight's timeout) for its thread, and a
+(`failed`). A run at `installed` or `workers` that finds this chi web already on its version (restarted by hand from the
+page's offer) goes straight to the finish. `AutoUpdate#stop` waits `STOP_WAIT` (25 s, longer than the preflight's timeout) for its thread, and a
 preflight that ends after a stop leads to nothing (no `web`, no exec): the next start takes the run up again. The restarted chi web's AutoUpdate (first step after 5 s) finds `phase: web`, checks it runs the
 release, counts the workers once more and publishes `updated`, then `done`, or `retrying` while workers are left. Those are
 retried each step until none is left or 24 h (`RETRY_FOR`) have passed since the install, under the same filter, and from

data/docs/cli.md

@@ -267,7 +267,9 @@ done
   in place, the notice gives the blocker and its command instead.
   With `update.auto: install` chi web installs the release by itself once no
   turn runs anywhere, then restarts idle workers and itself (`update.restart`),
-  and the notice reads "installs by itself" with no **Update** button; see
+  and the notice reads "installs by itself" with no **Update** button. A newer
+  chi installed from a terminal gets those restarts too, and no **Restart**
+  buttons unless the restart failed or has waited an hour; see
   [Unattended updates](configuration.md#unattended-updates-updateauto).
 
 - **The chi home.** With a [chi home](configuration.md#the-chi-home), a `chi
@@ -355,7 +357,8 @@ done
   terminal, no reminder) and `session.idle_exit_minutes` pass (never with 0).
   A new or woken worker always starts on the newest chi installed. A running
   `chi web` (on the port it was started with, else `web.port`) on an older chi needs a restart (Ctrl-C, then `chi web`):
-  its page says so too. One from before workers started on the newest chi
+  its page says so too. With `update.auto: install` it restarts by itself once no turn
+  runs ([Unattended updates](configuration.md#unattended-updates-updateauto)). One from before workers started on the newest chi
   also starts its new sessions on its own version until then (the row says so).
 
 `--dry-run` shows the table with "would update" and changes nothing. It is

data/docs/configuration.md

@@ -2163,9 +2163,22 @@ Both are read when chi web starts (restart it to apply a change). What it does,
    ([Phone notifications](#phone-notifications-web-push)); without it the page's toasts and
    `$XDG_STATE_HOME/samagotchi/update_check.json` (`auto`) are the record.
 
+**A chi installed some other way** (`chi update` in a terminal, a release newer than `update.min_age_hours` allows, a
+hand `gem install`) gets steps 3 and 4 too, with `update.restart: idle` and an install that isn't blocked: chi web notices it,
+waits for the next 5-minute look (`chi update` merges the bundles after installing the gem) and for the quiet moment of
+step 1, then restarts as above, so chi web is on it within about 10 minutes when nothing runs. A release it can install
+goes first. One run per version here too: a restart that didn't take isn't tried again.
+
+The page offers no **Restart** buttons while chi web is going to restart by itself. They come back, as a toast, when it
+won't (a failed run) or when something has held it for an hour (a forgotten question, a long turn); it keeps trying behind
+them. Worker restarts in such a run show no toast unless one fails, and the sheet behind **View** has only **Close**;
+the session's own **Restart** in its bar is always there.
+
 There is no watchdog: chi web restarts into the newest chi it just proved can start, and nothing brings an old one
-back by itself. To roll back, install the older gem with `gem install samagotchi -v X` and restart chi web
-(`chi update --to` refuses a version that isn't newer than the running chi). The desktop helper isn't rebuilt (that
+back by itself. To roll back, set `update.auto: off` (or the next check installs the release again), uninstall the newer
+gem with the chi home's Ruby (`gem uninstall samagotchi -v Y`: chi always starts the newest one installed, so installing an
+older gem beside it changes nothing), and restart chi web. `chi _X_ web` stays on X only with `update.auto: off`: a restart
+starts the newest. `chi update --to` refuses a version that isn't newer than the running chi. The desktop helper isn't rebuilt (that
 stays a manual `chi update`).
 
 ## All settings
@@ -2288,7 +2301,7 @@ column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 | `update.bundles` | `true` | | `false`: `chi update` leaves the shipped bundles to `chi bundle upgrade` (`--no-bundles`). |
 | `update.desktop` | `true` | | `false`: `chi update` leaves the desktop helper alone (`--no-desktop`). |
 | `update.notify` | `on` | | `on`: chi web checks RubyGems once a day and shows aged stable releases newer than both this chi and the newest installed chi; `off`: no thread or network check. |
-| `update.auto` | `off` | | `install`: chi web installs the release its checker found (aged by `update.min_age_hours`) once no turn runs and no question waits in any session, as the **Update** button would (shipped bundles merged, your edits kept and reported), then pushes how it went; `update.restart` says what follows. An install that fails is tried once per version (a newer release, or the **Update** button, tries again). The check runs even with `update.notify: off` (which then only silences the page's and the phone's "available"). An install that can't run here (a checkout, Bundler, an unwritable gem dir) stays a notice. `off`: notice only. See [Unattended updates](#unattended-updates-updateauto). |
+| `update.auto` | `off` | | `install`: chi web installs the release its checker found (aged by `update.min_age_hours`) once no turn runs and no question waits in any session, as the **Update** button would (shipped bundles merged, your edits kept and reported), then pushes how it went; `update.restart` says what follows, also for a chi installed some other way (`chi update` in a terminal). An install that fails is tried once per version (a newer release, or the **Update** button, tries again). The check runs even with `update.notify: off` (which then only silences the page's and the phone's "available"). An install that can't run here (a checkout, Bundler, an unwritable gem dir) stays a notice. `off`: notice only. See [Unattended updates](#unattended-updates-updateauto). |
 | `update.restart` | `idle` | | With `update.auto: install`: `idle` restarts the stale workers whose session is idle and untouched for 10 minutes, then chi web itself, once no turn runs anywhere and the newest chi has answered `chi --version`; it pushes "chi updated to X". `never`: the install only (the page's toast offers the restarts, workers also exit on their own when idle). |
 | `update.check_hours` | `24` | | Hours between RubyGems checks (at least 1). The first check starts about 30 seconds after chi web starts. |
 | `update.min_age_hours` | `24` | | A release must be this old before chi web offers it; `0` disables the age delay. |

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.146.0
+version: 0.147.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.146.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 } })

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";
@@ -585,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);
@@ -614,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) {

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

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

@@ -45,9 +45,10 @@ function statusText(model) {
 
 // Both restarts, once a newer chi is installed (an install done here, or the
 // installed notice's toast) and nothing runs: either result keeps the other in reach.
+// Not on an automatic run: it restarts them by itself.
 function restartActions(model) {
   const busy = ["starting", "running", "restarting"].includes(model.state);
-  if (!model.restartable || busy) return nothing;
+  if (!model.restartable || model.auto || busy) return nothing;
   return html`<button type="button" class="ghost" data-act="restart-workers">Restart workers</button>
     <button type="button" class="ghost" data-act="restart-web">Restart chi web</button>`;
 }
@@ -125,6 +126,8 @@ export function createUpdateSheet({ dialog, update, restartWorkers, restartWeb }
     model = {
       ...model,
       ...data,
+      // A frame names auto only when it is true: this run's word, not the last one's.
+      auto: data.auto === true,
       rows: Array.isArray(data.rows) ? data.rows : [],
     };
     if (data.operation === "install" && data.state === "done") restartable = true;

data/lib/samagotchi/web/session_access_routes.rb

@@ -274,7 +274,7 @@ module Samagotchi
                              model_name: session_access.show(id).model_name,
                              default_model: ModelProfile.default_model_name,
                              parent_strategy: strategy_json(session_access.parent_strategy(id)),
-                             **(@hub&.chi_state || { version: VERSION, installed: nil, available: nil, update_blocked: nil, auto: "off", restart: "idle" }) })
+                             **(@hub&.chi_state || { version: VERSION, installed: nil, available: nil, update_blocked: nil, auto: "off", restart: "idle", auto_offers: nil }) })
       rescue SessionManager::OwnedByTUI => e
         owned_by_tui(e)
       rescue SessionAccess::Refused => e

data/lib/samagotchi/web/session_hub.rb

@@ -41,8 +41,7 @@ module Samagotchi
 
       # What a subscriber gets: `session` with {session: summary} for an
       # upsert, `session_gone` with {id:} for a removal, `chi` with
-      #   {version:, installed:, available:, update_blocked:} when chi version
-      #   state changes. seq is monotonic per
+      #   the #chi_state fields when chi version state changes. seq is monotonic per
       # hub, for the log's sake: there is no replay.
       Event = Struct.new(:type, :seq, :data, keyword_init: true)
 
@@ -76,7 +75,7 @@ module Samagotchi
       # @param installed_versions [#newest] what is installed (InstalledVersions)
       # @param update_auto [String] update.auto, said in the chi state (the page's wording)
       # @param update_restart [String] update.restart, said beside it (whether
-      #   an automatic install's run restarts by itself: no Restart toast)
+      #   a newer installed chi restarts by itself: no Restart toast)
       def initialize(state_dir:, manager: SessionManager, now: nil, scan_interval: SCAN_INTERVAL,
                      full_probe_interval: FULL_PROBE_INTERVAL, installed_versions: InstalledVersions.new,
                      update_auto: Config.get("update.auto"), update_restart: Config.get("update.restart"))
@@ -87,6 +86,7 @@ module Samagotchi
         @installed = nil
         @available = nil
         @update_blocked = nil
+        @auto_offers = nil
         @update_state = nil
         @manager = manager
         @now = now || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
@@ -164,7 +164,7 @@ module Samagotchi
       def chi_state
         @monitor.synchronize do
           { version: VERSION, installed: @installed, available: @available, update_blocked: @update_blocked,
-            auto: @update_auto, restart: @update_restart }
+            auto: @update_auto, restart: @update_restart, auto_offers: @auto_offers }
         end
       end
 
@@ -180,6 +180,19 @@ module Samagotchi
         nil
       end
 
+      # AutoUpdate won't (or hasn't, for long) restart onto +version+ by itself:
+      # the page offers the restarts for it, in spite of update.auto. In memory:
+      # AutoUpdate says it again after a chi web restart.
+      def auto_offer_restart(version)
+        @monitor.synchronize do
+          next if @auto_offers == version
+
+          @auto_offers = version
+          emit("chi", chi_state)
+        end
+        nil
+      end
+
       # Publish the owner-triggered update's progress or result for current
       # tabs, and retain the latest state for a reconnect's snapshot.
       def publish_update(state:, rows:, progress: nil, operation: nil, version: nil, auto: false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.146.0
+  version: 0.147.0
 platform: ruby
 authors:
 - Dmitry Dedov