samagotchi 0.18.1 → 0.19.0

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

@@ -123,6 +123,12 @@ export function stopSession(id, opts = {}) {
   return api(`/api/sessions/${id}/stop`, { method: "POST", body: JSON.stringify({}), ...opts });
 }
 
+// Hands the session to a new worker on the newest chi installed: 200
+// {status, from_version, version}, or 409 with the reason in words (detail).
+export function restartSession(id, opts = {}) {
+  return api(`/api/sessions/${encodeURIComponent(id)}/restart`, { method: "POST", body: JSON.stringify({}), ...opts });
+}
+
 // Hides the session (and its delegates) from the lists, kept for good; the
 // server stops a live idle worker first and answers 409 while a turn runs.
 export function archiveSession(id, opts = {}) {

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

@@ -86,7 +86,9 @@ export function previewForCard(session) {
 
 const DELETE_PREVIEW_CHARS = 40;
 
-// The confirm before deleting a session (the info bar's and a card's).
+// The confirm before deleting a session (the info bar's and a card's). The
+// list's owner can be stale (a worker idle-exits), so a worker is only
+// "stopped if it's still running", never promised.
 export function deleteConfirmText(session) {
   const n = normalize(session.first_preview || session.last_prompt || "");
   const preview = n.length > DELETE_PREVIEW_CHARS ? `${n.slice(0, DELETE_PREVIEW_CHARS)}\u2026` : n;
@@ -95,7 +97,7 @@ export function deleteConfirmText(session) {
     `Delete session ${shortId}${preview ? ` \u2014 "${preview}"` : ""}?`,
     "Its history, notes and images are removed; this can't be undone.",
   ];
-  if (session.owner === "worker") lines.push("Its worker is running and will be stopped first.");
+  if (session.owner === "worker") lines.push("If its worker is still running, it is stopped first.");
   return lines.join("\n");
 }
 

data/lib/samagotchi/web/public/index.html

@@ -242,6 +242,11 @@ main{flex:1;display:flex;flex-direction:column;gap:16px;padding:16px;overflow:au
 .question-error{color:var(--danger);font-size:12px;margin-bottom:8px}
 .question-error.hidden{display:none}
 .question-result{margin-top:6px;font-size:12px;color:var(--ok);font-weight:600}
+/* 4.02: a resolved card whose summary already carries the result hides the
+   body line; a hand-toggled one keeps it (its expanded body shows it). */
+.question-result.hidden{display:none}
+/* N1: an approval's verdict sits above its command block, not after it. */
+.question-result.verdict{margin-top:0;margin-bottom:8px}
 .bubble.question.cancelled .question-result{color:var(--text-muted)}
 .question-submit{align-self:flex-end;font-size:13px}
 .question-dismiss{font-size:13px;margin-left:8px}
@@ -554,6 +559,12 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 #infoBar .meta .dir{font-family:ui-monospace,monospace;font-size:11px;color:var(--text-muted);word-break:break-all}
 #infoBar .meta .model{font-size:11px;padding:2px 6px;border-radius:6px;background:var(--bg-hover);color:var(--text-3)}
 #infoBar .meta .model.served-mismatch{background:var(--warn-bg);color:var(--warn-bright);border:1px solid var(--warn-border)}
+/* The open session's worker runs an older chi: its version, and Restart when it can. */
+#infoBar .meta .worker-badge{display:inline-flex;align-items:center;gap:6px;font-size:11px;padding:2px 2px 2px 6px;border-radius:6px;background:var(--warn-bg);color:var(--warn-bright);border:1px solid var(--warn-border);white-space:nowrap}
+#infoBar .meta .worker-badge:not(:has(button)){padding-right:6px}
+#infoBar .meta .worker-restart{padding:1px 8px;border-radius:5px;font-size:11px;font-weight:600;background:var(--bg-raised);color:var(--warn-bright);border:1px solid var(--warn-border)}
+#infoBar .meta .worker-restart:hover:not(:disabled){background:var(--warn-border);color:#fff}
+#infoBar .meta .worker-restart:disabled{opacity:.7;cursor:default}
 #infoBar .preview-line{font-size:13px;word-break:break-word;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2;line-clamp:2;overflow:hidden;line-height:1.4;max-height:2.8em}
 #infoBar .preview-line .preview, #infoBar .preview-line .mem{word-break:break-word}
 #infoBar .mem{font-size:12px;color:var(--text-muted)}

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

@@ -161,6 +161,18 @@ export function approvalAllowed(pq, answer) {
   return resultText(pq, { answer }).startsWith("Allowed");
 }
 
+// What the card says when an answer or a dismissal didn't go through. 503
+// (the server found no live bridge) reads as the session not running; any
+// other failure — the worker's own (the server maps it to a 502
+// bridge_error) or the connection's — shows what it said, so a worker that
+// failed the request is not mistaken for one that is gone.
+export function answerErrorText(error) {
+  const status = error?.status;
+  const message = String(error?.message ?? error ?? "");
+  if (status === 503 || /not_live/.test(message)) return "Session is not running — restart it to answer.";
+  return message;
+}
+
 // What a new question does to the card on the page: "same" (the card
 // already shows it: a replay), "keep" (the card is resolved, so it stays in
 // the history and the new one goes under it), "replace" (the card is still

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

@@ -15,8 +15,8 @@
 import { dismissQuestion, sendAnswer, sendCommand } from "./data.js";
 import { diffHtml } from "./diff_view.js";
 import {
-  approvalAllowed, approvalView, CONTINUE_REASON_PLACEHOLDER, isContinue, nextCardAction, relayedToView, resultText,
-  summaryText,
+  answerErrorText, approvalAllowed, approvalView, CONTINUE_REASON_PLACEHOLDER, isContinue, nextCardAction,
+  relayedToView, resultText, summaryText,
 } from "./question_card.js";
 import { sessionHash } from "./route.js";
 import { clientLabel, continueLine, isOwn } from "./turn_events.js";
@@ -148,9 +148,7 @@ export function createQuestionCards({
       }).catch((e) => {
         submit.disabled = false;
         card.classList.remove("submitting");
-        err.textContent = /503|not_live/.test(e.message)
-          ? "Session is not running — restart it to answer."
-          : e.message;
+        err.textContent = answerErrorText(e);
         err.classList.remove("hidden");
       });
     });
@@ -169,9 +167,7 @@ export function createQuestionCards({
       api.dismissQuestion(sessionId(), pq.id).catch((e) => {
         submit.disabled = false;
         dismiss.disabled = false;
-        err.textContent = /503|not_live/.test(e.message)
-          ? "Session is not running — restart it to answer."
-          : e.message;
+        err.textContent = answerErrorText(e);
         err.classList.remove("hidden");
       });
     });
@@ -210,7 +206,7 @@ export function createQuestionCards({
       api.sendAnswer(sessionId(), { id: pq.id, selected: [label], ...(freeform ? { freeform } : {}) }).catch((e) => {
         card.querySelectorAll("button, input").forEach((el) => { el.disabled = false; });
         card.classList.remove("submitting");
-        err.textContent = /503|not_live/.test(e.message) ? "Session is not running — restart it to answer." : e.message;
+        err.textContent = answerErrorText(e);
         err.classList.remove("hidden");
       });
     };
@@ -320,14 +316,20 @@ export function createQuestionCards({
     const note = doc.createElement("div");
     note.className = "question-result";
     note.textContent = result;
+    // N1: an approval's verdict goes before its command block, not after it:
+    // with the details expanded the command reads like another tool call.
+    const allowed = approvalAllowed(pending, answer);
+    if (allowed !== null) note.classList.add("verdict");
     if (cancelled) {
       questionEl.classList.add("cancelled");
     } else {
       questionEl.classList.add("answered");
-      if (approvalAllowed(pending, answer) === false) questionEl.classList.add("denied");
+      if (allowed === false) questionEl.classList.add("denied");
       markQuestionSelection(answer && Array.isArray(answer.selected) ? answer.selected : []);
     }
-    questionEl.appendChild(note);
+    const before = allowed !== null ? questionEl.querySelector(".approval-details") : null;
+    if (before) questionEl.insertBefore(note, before);
+    else questionEl.appendChild(note);
     questionEl.classList.remove("submitting");
     disableQuestionInputs();
     questionEl.querySelector(".question-relayed")?.classList.add("hidden");
@@ -335,6 +337,10 @@ export function createQuestionCards({
     // unless the user opened or closed it by hand.
     const summary = questionEl.querySelector("summary");
     if (summary) summary.textContent = summaryText(pending, { answer, cancelled, reason });
+    // 4.02: a reopened card's summary already carries the result (the
+    // snapshot re-renders it resolved), and the body line repeats it. It
+    // stays for a hand-toggled card, whose expanded body the user looks at.
+    if (summary && !questionEl.dataset.toggled) note.classList.add("hidden");
     if (!questionEl.dataset.toggled) questionEl.open = false;
     pending = null;
   }

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

@@ -10,14 +10,23 @@ export function scopeDir(search) {
 
 // The same place in the all view: the page without ?dir, keeping the hash.
 // +fromDir+ (the project view's folder) rides along as ?from=, so the all
-// view can link back to it.
-export function allScopeHref(hash, fromDir = null) {
-  return `/${fromDir ? `?from=${dirParam(fromDir)}` : ""}${hash || ""}`;
+// view can link back to it. +search+ (the page's location.search) keeps
+// its ?view= (VIEW_PARAM) on the new page.
+export function allScopeHref(hash, fromDir = null, search = "") {
+  const params = [fromDir ? `from=${dirParam(fromDir)}` : "", viewParam(search)].filter(Boolean);
+  return `/${params.length ? `?${params.join("&")}` : ""}${hash || ""}`;
 }
 
-// A folder's project view, keeping the hash.
-export function projectScopeHref(dir, hash) {
-  return `/?dir=${dirParam(dir)}${hash || ""}`;
+// A folder's project view, keeping the hash and +search+'s ?view=.
+export function projectScopeHref(dir, hash, search = "") {
+  const view = viewParam(search);
+  return `/?dir=${dirParam(dir)}${view ? `&${view}` : ""}${hash || ""}`;
+}
+
+// "view=<v>" from a location.search string, or "" without one.
+function viewParam(search) {
+  const view = new URLSearchParams(search || "").get("view");
+  return view ? `view=${encodeURIComponent(view)}` : "";
 }
 
 // A folder for the query string, its slashes left readable (as chi web

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

@@ -29,6 +29,10 @@ export function emptySessionState() {
     owner: null,
     // The session's commands (its worker's, plugins' too) for the / list.
     commands: [],
+    // The chi its live worker runs and what it can do (the session card's
+    // worker_version / worker_features): the info bar's stale-worker badge.
+    workerVersion: null,
+    workerFeatures: [],
     timing: normalizeTiming(),
   };
 }

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

@@ -20,10 +20,69 @@ export function workerGoneText({ turnRunning, stopped = false }) {
   return `\u2715 canceled (${stopped ? "session stopped" : "worker exited"})`;
 }
 
+// How long a turn's answer waits for the after_turn hooks' answer_display
+// before the page stops waiting and pops what it has (4.14).
+export const DISPLAY_WAIT_MS = 20000;
+
+// The wait between a turn_completed with display_pending and its
+// answer_display. The worker can die in between (a crash, a stop, an idle
+// exit) and never send one, so the wait also ends on the caller's finish()
+// (workerGone, a re-render) and by the timeout: it must never hold the
+// turn's answer bubble forever.
+// @return {{promise, finish, settled: () => Boolean}}
+export function displayWait({
+  timeoutMs = DISPLAY_WAIT_MS, setTimeoutImpl = setTimeout, clearTimeoutImpl = clearTimeout,
+} = {}) {
+  let settle = null;
+  let done = false;
+  const promise = new Promise((resolve) => { settle = resolve; });
+  const finish = () => {
+    if (done) return;
+    done = true;
+    clearTimeoutImpl(timer);
+    settle();
+  };
+  const timer = setTimeoutImpl(finish, timeoutMs);
+  return { promise, finish, settled: () => done };
+}
+
 // This tab's id in the events (`origin.client_id`, turn_enqueued's
-// client_id): new per page load, like the TUI's `tui:<pid>`.
-export function newClientId() {
-  return `web:${Math.random().toString(36).slice(2, 10).padEnd(8, "0")}`;
+// client_id): kept in sessionStorage per tab, so a reload mid-turn still
+// recognizes this tab's own prompt (4.03), which a fresh random id every
+// load labelled "web". Falls back to a fresh id when sessionStorage is
+// unavailable (a private window that refuses it) or holds nonsense.
+export const CLIENT_ID_KEY = "chi_client_id";
+export function newClientId(storage = safeSessionStorage()) {
+  const kept = readClientId(storage);
+  if (kept) return kept;
+  const id = `web:${Math.random().toString(36).slice(2, 10).padEnd(8, "0")}`;
+  writeClientId(storage, id);
+  return id;
+}
+
+function safeSessionStorage() {
+  try {
+    return globalThis.sessionStorage || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function readClientId(storage) {
+  try {
+    const value = storage?.getItem(CLIENT_ID_KEY);
+    return typeof value === "string" && /^web:/.test(value) ? value : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function writeClientId(storage, id) {
+  try {
+    storage?.setItem(CLIENT_ID_KEY, id);
+  } catch (_) {
+    // Full or refused storage: the id stays for this page only.
+  }
 }
 
 export function isOwn(clientId, myId) {
@@ -190,6 +249,17 @@ export function startPageReply(text, { images = 0 } = {}) {
   return images ? null : webLocalReply(text);
 }
 
+// The start page's reply to a first message that needs no session at all
+// (2.29): its own command's reply (startPageReply), or the hint for a
+// command word no command answers (a typo like /modle) — the hint the page
+// shows in a session too, as a command bubble. Decided before the session
+// is created, so a first /stats or /modle leaves none behind. A null here
+// means the message goes to a session (a prompt, or anything with images).
+export function startPageReplyOrHint(text, { commands = [], images = 0 } = {}) {
+  if (images) return null;
+  return startPageReply(text) || unknownCommandHint(text, commands);
+}
+
 // The continue card's answers, as the terminal's continue prompt reads them.
 export function continueLine(choice, reason = "") {
   const why = String(reason || "").trim();
@@ -257,6 +327,40 @@ export function restoreOnAck(enqueuedId, early, { myId, sentIds }) {
   return restoreAction(event, { myId, sentIds, composerEmpty: true });
 }
 
+// The /turn this kept entry was for failed: no ack comes, so nothing would
+// take it back. The whole map goes: this tab sends one turn at a time, so
+// every entry waits for an ack that is now never coming (an older one is
+// left over from a send that failed the same way).
+export function dropEarlyRestores(early) {
+  const count = early.size;
+  early.clear();
+  return count;
+}
+
+// The composer's text with a restored prompt put back into it: the restored
+// text alone when nothing is typed, else the typed text with the restored
+// prompt under it (the user typed between the restore and the ack; their
+// text must not be replaced).
+export function restoreInto(refill, current) {
+  const restored = String(refill ?? "");
+  const typed = String(current ?? "");
+  if (!restored) return typed;
+  if (!typed.trim()) return restored;
+  return `${typed.replace(/\n+$/, "")}\n${restored}`;
+}
+
+// What the composer holds once a /turn ack lands (4.13): the composer still
+// carries the text that was just sent, so that text goes (it is the history's
+// now) — but text typed since the send stays, and a prompt restored before
+// this ack (restoreOnAck's refill) is put back without replacing it.
+// @param sent the composer's text when the turn was sent
+// @param current the composer's text as the ack lands
+// @param refill the prompt an early restore handed back, if any
+export function composerAfterAck({ sent = "", current = "", refill = "" } = {}) {
+  const kept = String(current ?? "") === String(sent ?? "") ? "" : current;
+  return restoreInto(refill, kept);
+}
+
 // What an event does to the prompt bubbles, as a list of ops for app.js:
 //   add   — a bubble for a prompt this tab hasn't shown (state queued /
 //           started / steered, labelled by its sender)

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

@@ -1,15 +1,88 @@
-// An open tab keeps its JS across a `chi web` restart (its event streams
-// just reconnect), so after an upgrade old page code talks to a new server.
-// The page knows the version that served it (body data-version); each
-// GET /api/events snapshot names the one serving now.
-
-// The toast's text when the chi web serving now is another version than
-// the one that served this page, else null: also when either side doesn't
-// say (an older chi web, a page from before data-version), and when the
-// toast was already shown for this version (+shown+: the reconnects'
-// snapshots carry it again).
-export function updateNotice(loaded, served, shown = null) {
-  const known = (v) => typeof v === "string" && v !== "";
-  if (!known(loaded) || !known(served) || loaded === served || served === shown) return null;
-  return `chi was updated to ${served}`;
+// What the page says about chi versions. An open tab keeps its JS across a
+// `chi web` restart (its event streams just reconnect), so after an upgrade
+// old page code talks to a new server: the page knows the version that
+// served it (body data-version), and each GET /api/events snapshot names
+// the one serving now and the newest installed (`chi` frames when that
+// changes).
+
+const known = (v) => typeof v === "string" && v !== "";
+
+// Gem::Version's order, near enough: segments of digits or letters, a
+// missing one counts as 0, and letters (a prerelease: 0.19.0.pre1) sort
+// below any number. <0, 0 or >0.
+export function compareVersions(a, b) {
+  const parts = (v) => (v.match(/[0-9]+|[a-z]+/gi) || []).map((p) => (/^[0-9]+$/.test(p) ? Number(p) : p));
+  const x = parts(a);
+  const y = parts(b);
+  for (let i = 0; i < Math.max(x.length, y.length); i++) {
+    const p = i < x.length ? x[i] : 0;
+    const q = i < y.length ? y[i] : 0;
+    if (p === q) continue;
+    if (typeof p === "number" && typeof q === "number") return p - q;
+    if (typeof p === "number") return 1;
+    if (typeof q === "number") return -1;
+    return p < q ? -1 : 1;
+  }
+  return 0;
+}
+
+// Whether +a+ is a newer version than +b+ (false when either is unknown).
+export function newerVersion(a, b) {
+  return known(a) && known(b) && compareVersions(a, b) > 0;
+}
+
+// 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;
+//   only its terminal can restart it.
+// 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, 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)) {
+    notice = {
+      key: `installed:${installed}`,
+      text: `chi ${installed} is installed; this chi web runs ${served}. ` +
+        "Restart it: Ctrl-C in its terminal, then chi web",
+      reload: false,
+    };
+  }
+  return notice && !shown.has(notice.key) ? notice : null;
+}
+
+// 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
+// one can only be stopped (any message then starts it on the newest chi).
+// @return {{text, title, newest, restart: boolean} | null}
+export function workerBadge({ workerVersion, features, installed, served, sessionId = "" } = {}) {
+  const newest = known(installed) ? installed : served;
+  if (!newerVersion(newest, workerVersion)) return null;
+  if (Array.isArray(features) && features.includes("restart")) {
+    return {
+      text: `chi ${workerVersion}`,
+      title: `This session's worker runs chi ${workerVersion}; chi ${newest} is installed. ` +
+        `Restart hands the session to a new worker on chi ${newest}.`,
+      newest,
+      restart: true,
+    };
+  }
+  const stop = `chi sessions stop ${String(sessionId).slice(0, 8)}`;
+  return {
+    text: `chi ${workerVersion} · ${stop}`,
+    title: `This session's worker runs chi ${workerVersion}, which can't restart itself; chi ${newest} is installed. ` +
+      `Stop it (${stop}), then any message starts it on chi ${newest}.`,
+    newest,
+    restart: false,
+  };
+}
+
+// What the Restart confirm asks.
+export function restartConfirmText(workerVersion, newest) {
+  return `Restart this session's worker on chi ${newest} (it runs ${workerVersion})?\n\n` +
+    "The conversation stays, and this page and attached terminals move to the new worker. " +
+    "What lives only in the worker goes: kept /btw answers and plugins' in-memory state.";
 }

data/lib/samagotchi/web/server.rb

@@ -28,12 +28,16 @@ module Samagotchi
     class Server
       # WEBrick logs every exception out of its request loop as an ERROR with
       # a backtrace, among them a browser dropping a kept-alive connection
-      # (sock.eof? raising ECONNRESET): harmless, so not logged.
+      # (sock.eof? raising ECONNRESET): harmless, so not logged. Nor is the
+      # line it logs after answering a body-less POST (no Content-Length),
+      # when it tries to drain a body nobody read: the response already went.
       class Log < WEBrick::Log
         DROPPED = [Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED].freeze
+        DROPPED_LINES = ["HTTPRequest#fixup: WEBrick::HTTPStatus::LengthRequired occurred."].freeze
 
         def error(msg)
           return if DROPPED.any? { |klass| msg.is_a?(klass) }
+          return if msg.is_a?(String) && DROPPED_LINES.include?(msg)
 
           super
         end
@@ -125,6 +129,8 @@ module Samagotchi
                       annotate_presets: annotate_presets, hub: hub, lan: lan_option)
         Samagotchi::Log.info(:web, "start", url: "http://#{host}:#{port}", version: Samagotchi::VERSION)
         Samagotchi::Log.info(:web, "lan", ip: lan.ip, interface: lan.interface) if lan
+        # Subscribed before the first scan, which makes the first check.
+        hub.subscribe(method(:on_hub_event))
         hub.start
         # Said once the port is bound: a second chi web racing for it gets
         # the in-use line instead.
@@ -162,6 +168,27 @@ module Samagotchi
 
       class LanListenError < StandardError; end
 
+      # The hub's `chi` event: a newer chi installed than this chi web runs
+      # is said once in its terminal (the page says it too).
+      def self.on_hub_event(event)
+        return unless event.type == "chi"
+
+        line = installed_line(event.data[:installed])
+        return unless line
+
+        Samagotchi::Log.info(:web, "newer_installed", installed: event.data[:installed], version: Samagotchi::VERSION)
+        puts line
+        $stdout.flush
+      end
+
+      # nil unless +installed+ is newer than this chi web.
+      def self.installed_line(installed, running = Samagotchi::VERSION)
+        return nil unless InstalledVersions.newer?(installed, running)
+
+        "chi #{installed} is installed; this chi web runs #{running}. Restart it: Ctrl-C here, then chi web " \
+          "(new sessions already run #{installed})"
+      end
+
       # The LAN address's listener, next to the loopback one WEBrick made.
       # The loopback socket is bound by now: on a failure it is closed
       # here, as WEBrick never starts.

data/lib/samagotchi/web/session_hub.rb

@@ -9,6 +9,8 @@ require_relative "../session_manager"
 require_relative "../bridge_client"
 require_relative "../worker_sidecar"
 require_relative "../log"
+require_relative "../installed_versions"
+require_relative "../version"
 require_relative "session_summary"
 
 module Samagotchi
@@ -37,7 +39,9 @@ module Samagotchi
       FULL_PROBE_INTERVAL = 10.0
 
       # What a subscriber gets: `session` with {session: summary} for an
-      # upsert, `session_gone` with {id:} for a removal. seq is monotonic per
+      # upsert, `session_gone` with {id:} for a removal, `chi` with
+      # {version:, installed:} when the newest installed chi changed (checked
+      # with the full probe; #installed has it for a new tab). seq is monotonic per
       # hub, for the log's sake: there is no replay.
       Event = Struct.new(:type, :seq, :data, keyword_init: true)
 
@@ -68,9 +72,12 @@ module Samagotchi
       # @param manager [#session_owner, #retention_sweep_if_due] SessionManager,
       #   or a stand-in
       # @param now [#call] a monotonic clock in seconds (specs drive it)
+      # @param installed_versions [#newest] what is installed (InstalledVersions)
       def initialize(state_dir:, manager: SessionManager, now: nil, scan_interval: SCAN_INTERVAL,
-                     full_probe_interval: FULL_PROBE_INTERVAL)
+                     full_probe_interval: FULL_PROBE_INTERVAL, installed_versions: InstalledVersions.new)
         @state_dir = state_dir
+        @installed_versions = installed_versions
+        @installed = nil
         @manager = manager
         @now = now || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
         @scan_interval = scan_interval
@@ -120,11 +127,19 @@ module Samagotchi
           full = full_probe_due?
           scan_files
           @sessions.each_key { |id| refresh(id, probe: full) }
-          sweep if full
+          if full
+            sweep
+            check_installed
+          end
         end
         nil
       end
 
+      # The newest installed chi as of the last full probe (nil: unknown).
+      def installed
+        @monitor.synchronize { @installed }
+      end
+
       # Rescan one session now (its file, its folder, its owner), for the
       # page's own actions: no waiting for the next tick.
       def touch(id)
@@ -202,6 +217,18 @@ module Samagotchi
         nil
       end
 
+      # A change (the first look too, unless it finds nothing) is a `chi`
+      # event: chi web's terminal line and the open tabs hear it.
+      def check_installed
+        newest = @installed_versions.newest
+        return if newest == @installed
+
+        @installed = newest
+        emit("chi", version: VERSION, installed: newest)
+      rescue StandardError => e
+        Log.warn(:web, "installed_check_failed", error: e.class.name, msg: e.message)
+      end
+
       # The state dir's files: a new id is parsed and emitted, an id gone
       # from disk is dropped, a changed file is re-parsed. Skipped when the
       # dir's mtime says nothing was renamed in or unlinked since.

data/lib/samagotchi/web/session_summary.rb

@@ -30,6 +30,7 @@ module Samagotchi
       def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil)
         used = Array(session.used_memory_names)
         up = bridge_up?(session_dir, owner)
+        sidecar = up ? WorkerSidecar.read(session_dir) : nil
         {
           id: session.id,
           status: status,
@@ -59,6 +60,10 @@ module Samagotchi
           # A worker is reachable: its Bridge sidecar is there and the
           # owner lock is held. A sidecar a dead worker left is not up.
           bridge_up: up,
+          # The chi the live worker runs and what it can do (its sidecar;
+          # nil and [] without one): the page's stale-worker badge.
+          worker_version: sidecar&.version,
+          worker_features: sidecar ? sidecar.features : [],
           # For the tab's notifications (notify.js): an open question, the
           # running turn's open card with actions, and how the last turn
           # ended. A question saved by a worker that died is not open, nor a