samagotchi 0.111.0 → 0.111.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3030ebe01072de864d730b27cfc709368d48948260f07b3e37fa83f8ba4b87a
-  data.tar.gz: 38f33d3c633d5467c8200817c2a12fc5fd0e287cf87cbd5233f0486326280eed
+  metadata.gz: 2153d4c9c7afa58d9d06d330d1839a021032df3502f515d4a093bad7f9dde347
+  data.tar.gz: 9ac11fddf172afa0eb4c5ea520d3e64471c0b2502753539fafcce28aa4e99294
 SHA512:
-  metadata.gz: af19fcb8e29f712f43098d68d466bb8e68bdfc3b87177d7a2f99e73a2b609a535322ab181cacae03d7cf00e774a2f28933ff5b3ba30446d3e4112724f213bf6f
-  data.tar.gz: 72fb51ec5f3d216a36e27a040643517104fc8988f8010b6bdc70ac4f3b2bd2db281a4cc629a54b75e88dfbe46b78d02014bfc65142f39e40e6952ab13c919f7f
+  metadata.gz: cc73ef6cdd220a1dfb83b4e1b6f51ba4e42c80eff05ae661363b06d4d53b9bf4c0c2c954173997475571518ed98e7f589afe0eb9251787e3a894eab8dd1fec00
+  data.tar.gz: 9105631a20fcfe1e6889dbc904e146c4fcc68c75e5879111e589efe515ecaaecd4e03b6e7a3f389eb674bd1b0c0bb6a1420dca439b01cdefe04ed508d0830c9a

data/CHANGELOG.md

@@ -8,6 +8,20 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.111.1] - 2026-10-25
+
+### Fixed
+
+- `chi --remote NAME send --wait` with no message (and one whose message merged into the running turn) ends
+  `canceled` (`worker_stopped`) when that turn's worker dies and the next worker settles it between two of chi web's
+  30 s wait slices, as it does on this machine, instead of waiting until `--timeout`.
+- chi web: turning the phone's bell off and on again now replaces a subscription iOS dropped silently, instead of
+  keeping the dead one in `subscriptions.json`.
+- chi web: a Home Screen app left open for days picks up a newer service worker (after `chi update`) when it comes
+  back to the front.
+
+Update with `chi update` (the system bundle 0.111.1), then restart `chi web`.
+
 ## [0.111.0] - 2026-10-24
 
 ### Added
@@ -4250,7 +4264,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.111.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.111.1...HEAD
+[0.111.1]: https://github.com/dm1try/samagotchi/compare/v0.111.0...v0.111.1
 [0.111.0]: https://github.com/dm1try/samagotchi/compare/v0.110.0...v0.111.0
 [0.110.0]: https://github.com/dm1try/samagotchi/compare/v0.109.0...v0.110.0
 [0.109.0]: https://github.com/dm1try/samagotchi/compare/v0.108.0...v0.109.0

data/docs/configuration.md

@@ -1800,7 +1800,8 @@ is in the background), as before.
 - **The files**: `$XDG_STATE_HOME/samagotchi/web-push/` (next to `web-token`): `vapid.pem` (chi web's key) and
   `subscriptions.json` (the devices), 0600 in a 0700 folder; chi web refuses to start when others can read them.
   Subscriptions belong to the public URL they were made on: after renaming the machine or the tailnet, turn the bell
-  on again on the phone (the old ones are never sent to).
+  on again on the phone (the old ones are never sent to). iOS can drop a subscription without telling chi web; if
+  notifications stop arriving, turn the bell off and on again: the new subscription replaces the dead one.
 - `web.push.enabled: false` turns it off; `web.push.contact` (a `mailto:` address or an `https://` URL; default:
   the public URL) is the contact the push services see in chi web's key. A value that is neither stops `chi web`
   (Apple refuses it); a `[chi web] the push service refused chi's VAPID token` line means the contact or the key was

data/docs/internals/remote-sessions.md

@@ -98,7 +98,11 @@ registry flag (`--recap-base-url` …) is this machine's config: `LOCAL_ONLY` wi
 5. **The wait.** `ParentWait#wait_for_reply` → `Remote#wait_reply` loops on `POST …/wait` with
    `timeout: min(time left, WAIT_SLICE)` (30 s). The server runs `ReplyWait.call` for at most `WAIT_MAX_SECONDS` (30 s)
    and returns the `ReplyWait::Result` fields plus `parent_strategy`. On a `timeout` status the client asks again until
-   its own `--timeout` runs out, at which point it builds the `timeout` result itself. A 503 `server_stopping` (chi web
+   its own `--timeout` runs out, at which point it builds the `timeout` result itself. Each slice is a fresh `ReplyWait`
+   there, so a `timeout` answer carries the slice's `running_look` (`ReplyWait::RunningLook`: the running turn it saw
+   with its checkpoint mark, `{last_end, claimed}`, else null) and the client sends it back on the next slice, as is:
+   a dead worker's turn settled between two slices ends the wait `canceled` (`worker_stopped`) as it does locally,
+   not at the timeout. A 503 `server_stopping` (chi web
    shutting down mid-wait: `ReplyWait`'s `cancelled:` returns `:canceled`) is retried after `RETRY_AFTER` (1 s).
    `HTTPTransport::READ_TIMEOUT` (75 s) is set above the longest answer, a wait slice or a create's wait for its worker.
 6. **The report.** `ParentReport.report` prints it as it does locally. It uses `Remote#parent_strategy`, which

data/docs/internals/web-push.md

@@ -57,7 +57,11 @@ files, one per machine, never in config.yml:
 `invalid_subscription`): an endpoint and both keys; https on port 443 without userinfo, at most 2048 bytes; a host in
 `Store::PUSH_SERVICES` (Apple, Google's FCM, Mozilla, `*.notify.windows.com`; a `services:` seam for specs, not
 config): chi web POSTs to that URL, so it never takes an arbitrary host; `p256dh` a 65-byte uncompressed point,
-`auth` 16 bytes. The same endpoint again replaces the old entry. Every write is a read-change-write under
+`auth` 16 bytes. The same endpoint again replaces the old entry. `replaces:` (the device's id from its last
+subscribe, which the page keeps) drops that entry on this origin too, before the `MAX_SUBS` cap is counted, and
+yields it (the route logs `push_replaced`); its own endpoint is never dropped that way, and an unknown id is ignored.
+That is how a subscription iOS revoked silently (Apple keeps answering 201, so `:gone` never comes) leaves the store:
+the user turns the bell off and on, the page has no live subscription to delete, and the new one replaces it. Every write is a read-change-write under
 `store.lock` (chi web's request threads and the sender thread both write). A `subscriptions.json` that doesn't read
 lists no device and is never written over. `Store#check_permissions!` uses `Web::PrivateFiles.check!`, the check the
 grants use, worded with what the folder holds; `Server.launch` runs it (`Push.preflight!`, with the contact and the
@@ -93,7 +97,10 @@ show iOS refuses is shown once more without its icon and data. A show calls `sho
 icon, data: {url}})` first; then, when `open` is an array, closes every `getNotifications()` whose tag is a
 question's `"<sid>:<qid>"` (never `chi:*`), isn't the new one and isn't in `open` (after the show: closing before it
 fails on iOS; errors are swallowed); then `setAppBadge(badge)` when `badge` is a number. A tap focuses the app's first window and navigates it to the url, else opens one (only a path of chi web's); `install`
-skips waiting, `activate` claims the clients. No fetch handler and no caching: chi web has no offline mode, and a
+skips waiting, `activate` claims the clients. A Home Screen app can stay open for days, and the browser checks for
+a newer `sw.js` only on `register()` and on navigations: so when the page comes back in front (`backInFront` in
+`notifications.js`) it calls `reg.update()` (errors swallowed), at most once per `SW_UPDATE_MS` (an hour; counted
+from the register, which has just checked), with the bell on or off, never without push. No fetch handler and no caching: chi web has no offline mode, and a
 fetch handler would change how the page loads. `spec/web/public/sw.test.js` runs it in a `vm` with a fake worker
 scope.
 
@@ -145,8 +152,9 @@ public URL, or `web.push.enabled: false`):
 
 - `GET /api/push[?endpoint=E]` → `{enabled, public_key, origin, this: {id, label}|null}`; off: `enabled: false` and
   no key.
-- `POST /api/push/subscriptions {subscription: {endpoint, keys}}` → 201 `{id, label}`; the label is chi's own
-  ("iPhone · <date>", from the User-Agent's device class: iPhone, iPad, Mac, else Browser).
+- `POST /api/push/subscriptions {subscription: {endpoint, keys}, replaces?: id}` → 201 `{id, label}`; the label is
+  chi's own ("iPhone · <date>", from the User-Agent's device class: iPhone, iPad, Mac, else Browser); `replaces`
+  drops the device's earlier entry (`Store#add`).
 - `DELETE /api/push/subscriptions {endpoint}` → 204.
 - `POST /api/push/test {endpoint?}` → a test push to that device or every one on this origin, answered per device
   (`{devices: [{id, label, status, code, ms}]}`); the bell sends one after subscribing.
@@ -160,8 +168,10 @@ standalone app: `matchMedia("(display-mode: standalone)")` or iOS's `navigator.s
 `subscribe({reg, key, post})` (drops a subscription made with another key), `unsubscribe({reg, del})`. In the Home
 Screen app the bell (`notifications.js`) registers `/sw.js`, asks `GET /api/push` with its subscription's endpoint,
 and is "push to this phone" when chi web pushes: on while chi web has this device. A tap asks permission from the tap
-(iOS asks only from a user gesture), subscribes, posts it and sends a test push; a tap when on unsubscribes and
-deletes. The tab's own OS notification is left to the push there; the title count stays. In a browser tab, or with
+(iOS asks only from a user gesture), subscribes, posts it (with `replaces`: the id chi web answered last time,
+kept in localStorage as `chi_push_device`, `PUSH_DEVICE_KEY`; a storage that throws only loses the replace) and sends
+a test push; a tap when on unsubscribes and deletes, and forgets the id, unless there was no subscription left to
+delete (revoked meanwhile): then the id stays for the next subscribe to replace. The tab's own OS notification is left to the push there; the title count stays. In a browser tab, or with
 chi web not pushing, the bell is the in-tab one, unchanged (no duplicate desktop pushes).
 
 **The device's tidy-up** (`syncDevice`, the Home Screen app with the bell on): closes the shown notifications whose

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

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

data/lib/samagotchi/reply_wait/poll.rb

@@ -15,7 +15,7 @@ module Samagotchi
     # them. ReplyWait.call's parameters say what each means.
     class Poll
       def initialize(id, state_dir:, cursor:, timeout:, poll_interval:, cancelled:, baseline:, owner_grace:, interject:,
-                     turn:, queued:, ended_before:)
+                     turn:, queued:, ended_before:, running_look: nil)
         @id = id
         @state_dir = state_dir
         @cursor = cursor
@@ -41,10 +41,10 @@ module Samagotchi
         @own_base = nil
         @seen_running = false
         # A turn seen running with its checkpoint mark (a wait with no
-        # turn:): last_turn's ended_at then and the input files claimed
-        # then, so its settle by a next worker (#settled_running) tells
+        # turn:; RunningLook), by this call or an earlier one of the same
+        # wait, so its settle by a next worker (#settled_running) tells
         # from a turn that ended or an input that runs next.
-        @running_look = nil
+        @running_look = running_look
         @gone_since = nil
       end
 
@@ -264,15 +264,14 @@ module Samagotchi
         nil
       end
 
-      RunningLook = Data.define(:last_end, :claimed)
-
       def note_running(session)
         return unless session.interrupted_turn
 
-        @running_look = RunningLook.new(last_end: session.last_turn&.ended_at,
-                                        claimed: SessionInbox.claimed_input_files(@session_dir))
+        @running_look = RunningLook.new(last_end: session.last_turn&.ended_at, claimed: claimed_names)
       end
 
+      def claimed_names = SessionInbox.claimed_input_files(@session_dir).map { |path| File.basename(path) }.sort.freeze
+
       # The turn seen running is gone with no turn's end: its worker died
       # in it and the next one settled it (TurnCheckpoint.settle: idle, the
       # mark gone, last_turn left alone), which ends a wait for it (chi
@@ -287,7 +286,7 @@ module Samagotchi
         return nil unless look && session.status == Session::STATUS_IDLE && session.interrupted_turn.nil? &&
                           session.last_turn&.ended_at == look.last_end
         return nil unless SessionInbox.find_new_input_files(@session_dir).empty?
-        return nil unless (SessionInbox.claimed_input_files(@session_dir) - look.claimed).empty?
+        return nil unless (claimed_names - look.claimed).empty?
 
         Result.new(status: :no_reply, outcome: "canceled", cancel_reason: TurnCheckpoint::WORKER_STOPPED, session: session)
       end
@@ -303,7 +302,9 @@ module Samagotchi
         nil
       end
 
-      def timed_out = @deadline && ReplyWait.monotonic > @deadline ? Result.new(status: :timeout) : nil
+      def timed_out
+        @deadline && ReplyWait.monotonic > @deadline ? Result.new(status: :timeout, running_look: @running_look) : nil
+      end
 
       # Whether the session's last turn is the one that had ended at the
       # baseline (its ended_at set and unchanged).

data/lib/samagotchi/reply_wait.rb

@@ -63,8 +63,31 @@ module Samagotchi
     # @!attribute origin [String, nil] "command" for a :no_reply that a
     #   file-delivered session command settled (no turn ran:
     #   TurnCheckpoint.record_command_outcome); nil otherwise
+    # @!attribute running_look [RunningLook, nil] on a :timeout, the turn
+    #   this wait saw running (call's running_look:, for a wait that goes
+    #   on in a next call: chi web's 30 s slices of a remote wait)
     Result = Struct.new(:status, :text, :file, :question, :outcome, :limit, :error_kind, :retryable, :cancel_reason,
-                        :stopped_by, :kept_steps, :session, :turn_id, :origin, keyword_init: true)
+                        :stopped_by, :kept_steps, :session, :turn_id, :origin, :running_look, keyword_init: true)
+
+    # A turn a wait with no turn: saw running with its checkpoint mark:
+    # last_turn's ended_at then and the names of the input files claimed
+    # then (*.json.processing), so its settle by a next worker tells from
+    # a turn that ended or an input that runs next (Poll#settled_running).
+    # Plain strings, so a remote wait carries it from one slice to the next.
+    RunningLook = Data.define(:last_end, :claimed) do
+      # @return [RunningLook, nil] nil unless +raw+ is {last_end: String or
+      #   nil, claimed: [file names]} (string keys, as JSON parsed it)
+      def self.from_h(raw)
+        return nil unless raw.is_a?(Hash) && raw.keys.sort == %w[claimed last_end]
+
+        last_end = raw["last_end"]
+        claimed = raw["claimed"]
+        return nil unless (last_end.nil? || last_end.is_a?(String)) && claimed.is_a?(Array) &&
+                          claimed.all? { |name| name.is_a?(String) && File.basename(name) == name }
+
+        new(last_end: last_end, claimed: claimed.sort.freeze)
+      end
+    end
 
     # The session as it was before a message went in (call's baseline:,
     # #baseline_of): its message count, the question pending then, and when
@@ -133,13 +156,17 @@ module Samagotchi
     #   sorts at the cursor, not past it, and its end precedes the
     #   baseline, so without it the wait would time out "running" again.
     #   Not for a turn: wait (chi answer) whose own end it waits for.
+    # @param running_look [RunningLook, nil] the running turn an earlier
+    #   call of the same wait saw (its :timeout result's running_look): its
+    #   settle ends this call too, as if this call had seen it running
     # @return [Result]
     # @raise [ArgumentError] no such session
     def call(id, state_dir:, cursor:, timeout: nil, poll_interval: POLL_INTERVAL, cancelled: -> { false },
-             baseline: nil, owner_grace: nil, interject: nil, turn: nil, queued: false, ended_before: false)
+             baseline: nil, owner_grace: nil, interject: nil, turn: nil, queued: false, ended_before: false,
+             running_look: nil)
       Poll.new(id, state_dir: state_dir, cursor: cursor, timeout: timeout, poll_interval: poll_interval,
                    cancelled: cancelled, baseline: baseline, owner_grace: owner_grace, interject: interject, turn: turn,
-                   queued: queued, ended_before: ended_before).run
+                   queued: queued, ended_before: ended_before, running_look: running_look).run
     end
 
     # The session as it was before a message went in (call's baseline:):

data/lib/samagotchi/session_access/remote.rb

@@ -333,7 +333,9 @@ module Samagotchi
       end
 
       # ReplyWait on the server, asked again each WAIT_SLICE until it ends
-      # or +timeout+ passes.
+      # or +timeout+ passes. Each slice is a fresh ReplyWait there: the
+      # running turn a slice saw (its timeout's running_look) goes into the
+      # next, so a settle between two slices ends the wait as it would here.
       # @return [ReplyWait::Result]
       # @raise [ArgumentError] the session is gone
       def wait_reply(id, cursor:, timeout:, baseline:, owner_grace: nil, turn: nil, queued: false, ended_before: false,
@@ -356,6 +358,8 @@ module Samagotchi
           @strategies[id] = strategy_of(reply.json["parent_strategy"])
           result = result_of(reply.json)
           return result unless result.status == :timeout
+
+          body[:running_look] = reply.json["running_look"]
         end
       end
 

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/participant_access.rb

@@ -341,7 +341,7 @@ module Samagotchi
         grant = principal(req).grant
         return not_permitted_for(req, principal(req)) unless own_turn?(grant, id, options[:turn])
 
-        options = options.merge(queued: true, cursor: nil)
+        options = options.merge(queued: true, cursor: nil, running_look: nil)
         session = session_access.show(id)
         result = session_access.wait_reply(id, **options, poll_interval: @wait_poll_interval,
                                                cancelled: -> { !@server_running.call || !@grants.active?(grant.id) })

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

@@ -25,6 +25,13 @@ import {
 } from "./push.js";
 
 export const NOTIFY_KEY = "chi_notify";
+// The device id chi web gave this app's subscription (POST subscribe's
+// answer): the next subscribe sends it as replaces, so a subscription iOS
+// revoked silently (its push service keeps answering 201) leaves the store.
+export const PUSH_DEVICE_KEY = "chi_push_device";
+// A long-lived Home Screen app checks for a new sw.js at most this often
+// when it comes back in front (reg.update()).
+export const SW_UPDATE_MS = 60 * 60 * 1000;
 
 const NOTIFY_TITLES = {
   on: "Notifications on: a session that needs you while this tab is in the background. Click to turn off",
@@ -68,6 +75,7 @@ function defaultChannel() {
 // @param api (method, path, body) => Promise of chi web's JSON
 // @param scoped the page shows one project's sessions (?dir=): it never
 //   tidies the device, as it doesn't see the others'
+// @param now () => ms (the service worker update's spacing; specs)
 // @return {noticeSessions(type, data), noticeList(sessions), setBaseTitle(title), clearBadge()}
 export function createNotifications({
   button,
@@ -80,6 +88,7 @@ export function createNotifications({
   nav = globalThis.navigator,
   api = defaultApi,
   scoped = false,
+  now = () => Date.now(),
 }) {
   let attention = initialAttentionState();
   // Web Push in the Home Screen app: null until chi web says it pushes
@@ -88,6 +97,8 @@ export function createNotifications({
   let pushBusy = false;
   let syncing = null;
   let syncAgain = false;
+  // When this page last had the browser check for a newer sw.js.
+  let swCheckedAt = null;
   const badgeKeys = new Set();
   let baseTitle = "Chi";
 
@@ -101,6 +112,17 @@ export function createNotifications({
     return doc.visibilityState === "visible" && doc.hasFocus();
   }
 
+  function stored(key) {
+    try { return storage().getItem(key); } catch (_) { return null; }
+  }
+
+  function store(key, value) {
+    try {
+      if (value == null) storage().removeItem(key);
+      else storage().setItem(key, value);
+    } catch (_) {}
+  }
+
   function notifyWanted() {
     try { return storage().getItem(NOTIFY_KEY) === "1"; } catch (_) { return false; }
   }
@@ -148,13 +170,19 @@ export function createNotifications({
     let failed = null;
     try {
       if (push.on) {
-        await pushUnsubscribe({ reg: push.reg, del: (endpoint) => api("DELETE", "/api/push/subscriptions", { endpoint }) });
+        const had = await pushUnsubscribe({ reg: push.reg, del: (endpoint) => api("DELETE", "/api/push/subscriptions", { endpoint }) });
+        // Without a subscription to delete (revoked meanwhile) the id stays
+        // for the next subscribe to replace.
+        if (had) store(PUSH_DEVICE_KEY, null);
         push.on = false;
         setDeviceBadge(0);
       } else if (NotificationApi.permission === "granted" || (await NotificationApi.requestPermission()) === "granted") {
-        const { subscription } = await pushSubscribe({
-          reg: push.reg, key: push.key, post: (json) => api("POST", "/api/push/subscriptions", { subscription: json }),
+        const replaces = stored(PUSH_DEVICE_KEY);
+        const { subscription, answer } = await pushSubscribe({
+          reg: push.reg, key: push.key,
+          post: (json) => api("POST", "/api/push/subscriptions", replaces ? { subscription: json, replaces } : { subscription: json }),
         });
+        if (answer?.id) store(PUSH_DEVICE_KEY, answer.id);
         push.on = true;
         api("POST", "/api/push/test", { endpoint: subscription.endpoint }).catch(() => {});
         syncDevice();
@@ -180,11 +208,23 @@ export function createNotifications({
       const info = await api("GET", `/api/push${query}`);
       if (!info?.enabled || !info.public_key) return;
       push = { reg, key: info.public_key, on: !!(sub && info.this) };
+      // register() has just checked for a newer sw.js.
+      swCheckedAt = now();
       renderNotifyBtn();
     } catch (_) {}
     syncDevice();
   }
 
+  // A Home Screen app can stay open for days: when it comes back in front
+  // it asks for a newer sw.js, at most once per SW_UPDATE_MS.
+  function updateWorker() {
+    if (!push || typeof push.reg?.update !== "function") return;
+    const at = now();
+    if (swCheckedAt !== null && at - swCheckedAt < SW_UPDATE_MS) return;
+    swCheckedAt = at;
+    try { push.reg.update()?.catch?.(() => {}); } catch (_) {}
+  }
+
   function setDeviceBadge(count) {
     try {
       const done = count > 0 && typeof nav?.setAppBadge === "function" ? nav.setAppBadge(count)
@@ -279,6 +319,7 @@ export function createNotifications({
     if (doc.visibilityState !== "visible") return;
     clearBadge();
     syncDevice();
+    updateWorker();
   }
   doc.addEventListener("visibilitychange", backInFront);
   win.addEventListener("focus", backInFront);

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

@@ -158,20 +158,30 @@ module Samagotchi
         # Adds the subscription a page's pushManager.subscribe gave (its
         # JSON: endpoint, keys {p256dh, auth}); the same endpoint again
         # replaces the old entry (a device subscribing again).
+        # +replaces+ is the short id this device had before (the page keeps
+        # it): that entry on +origin+ goes too, before the cap is counted,
+        # since the device has a new endpoint and the old one is dead (iOS
+        # revokes silently: its push service keeps answering 201). Yields
+        # the entry dropped that way, if any; an unknown id is ignored.
         # @return [Sub]
         # @raise [Invalid] one message per refusal
-        def add(subscription, origin:, label:)
+        def add(subscription, origin:, label:, replaces: nil)
           endpoint, p256dh, auth = validate(subscription)
           at = stamp(now)
           sub = Sub.new(id: Store.short_id(endpoint), endpoint: endpoint, p256dh: p256dh, auth: auth, origin: origin,
                         label: label.to_s[0, LABEL_MAX], created_at: at, last_ok_at: nil, last_error: nil,
                         prefs: { "done" => false })
-          update do |subs|
+          replaced = nil
+          added = update do |subs|
             kept = subs.reject { |old| old.endpoint == endpoint }
+            replaced = kept.find { |old| old.id == replaces && old.origin == origin } if replaces.is_a?(String)
+            kept -= [replaced] if replaced
             raise Invalid, "chi web already pushes to #{MAX_SUBS} devices: turn the bell off on one first" if kept.size >= MAX_SUBS
 
             [kept + [sub], sub]
           end
+          yield replaced if replaced && block_given?
+          added
         end
 
         # Removes the subscription with this short id or endpoint.

data/lib/samagotchi/web/push_routes.rb

@@ -29,14 +29,19 @@ module Samagotchi
                              origin: @push.origin, this: this && { id: this.id, label: this.label } })
       end
 
-      # {subscription: {endpoint, keys: {p256dh, auth}}} → 201 {id, label}.
+      # {subscription: {endpoint, keys: {p256dh, auth}}, replaces?: id} →
+      # 201 {id, label}. +replaces+ is the id this device was given before
+      # (the page keeps it): that entry goes (Store#add).
       def handle_push_subscribe(req)
         return push_off unless @push
 
         body = push_body(req)
         return error_response(400, "invalid_json", "invalid JSON body") unless body.is_a?(Hash)
 
-        sub = @push.store.add(body["subscription"], origin: @push.origin, label: device_label(req))
+        sub = @push.store.add(body["subscription"], origin: @push.origin, label: device_label(req),
+                                                    replaces: body["replaces"]) do |old|
+          Log.info(:web, "push_replaced", device: old.id)
+        end
         Log.info(:web, "push_subscribed", device: sub.id)
         json_response(201, { id: sub.id, label: sub.label })
       rescue Push::Store::Invalid => e

data/lib/samagotchi/web/session_access_routes.rb

@@ -171,13 +171,16 @@ module Samagotchi
       # (SessionAccess::Local#wait_reply). Body: cursor, baseline
       # ({messages, question_id, last_turn}, as the prepare route gave it),
       # turn, queued, ended_before, owner_grace (seconds, null: wait for
-      # whatever wakes a worker), timeout (seconds, capped). 200: the
-      # ReplyWait::Result's fields (status: done, waiting_for_answer,
-      # no_reply, error, stopped, timeout or worker_gone; text, file,
-      # question, outcome, …; never the Session) and parent_strategy, what
-      # a parent may pick on the session's questions here
-      # (ParentReport.strategy_for). A timeout status: ask again. 503
-      # server_stopping when chi web stops mid-wait.
+      # whatever wakes a worker), timeout (seconds, capped), running_look
+      # (the last timeout's, as it came). 200: the ReplyWait::Result's
+      # fields (status: done, waiting_for_answer, no_reply, error, stopped,
+      # timeout or worker_gone; text, file, question, outcome, …; never the
+      # Session) and parent_strategy, what a parent may pick on the
+      # session's questions here (ParentReport.strategy_for). A timeout
+      # status: ask again, with its running_look ({last_end, claimed}, or
+      # null: the running turn this slice saw, so a settle between two
+      # slices still ends the wait). 503 server_stopping when chi web stops
+      # mid-wait.
       def handle_wait(req, id)
         body = body_hash(req) or return error_response(400, "invalid_json", "invalid JSON body")
         options, error = wait_options(body)
@@ -209,8 +212,15 @@ module Samagotchi
         end
 
         timeout = [numbers["timeout"] || WAIT_MAX_SECONDS, WAIT_MAX_SECONDS].min
+        look = body["running_look"]
+        running_look = look.nil? ? nil : ReplyWait::RunningLook.from_h(look)
+        if !look.nil? && running_look.nil?
+          return [nil, error_response(400, "invalid_wait", "running_look is {last_end, claimed: [file names]}")]
+        end
+
         [{ cursor: strings["cursor"], turn: strings["turn"], baseline: baseline, timeout: timeout,
-           owner_grace: numbers["owner_grace"], queued: body["queued"] == true, ended_before: body["ended_before"] == true }, nil]
+           owner_grace: numbers["owner_grace"], queued: body["queued"] == true, ended_before: body["ended_before"] == true,
+           running_look: running_look }, nil]
       end
 
       def wait_baseline(raw)
@@ -231,6 +241,7 @@ module Samagotchi
         RESULT_FIELDS.each { |key| json[key] = result[key] }
         json[:text] = json[:text]&.dup&.force_encoding(Encoding::UTF_8)&.scrub
         json[:question] = result.question&.to_file
+        json[:running_look] = result.running_look&.to_h
         json[:parent_strategy] = strategy_json(strategy)
         json
       end

metadata

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