samagotchi 0.18.0 → 0.19.0

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

data/lib/samagotchi/worker.rb

@@ -16,6 +16,7 @@ require_relative "continue_offer"
 require_relative "iteration_limit"
 require_relative "session_commands"
 require_relative "model_profile"
+require_relative "tools/task_runtime"
 
 module Samagotchi
   # The loop of a background session worker, once it owns the session (see
@@ -85,6 +86,8 @@ module Samagotchi
       @exit_requested_by = nil
       # Set as it leaves: nothing happened in the session (#discard?).
       @discard = false
+      # The exit asked for is a restart (POST /exit restart: true).
+      @exit_restart = false
     end
 
     # Whether the session was empty as the worker left it, so the caller
@@ -96,7 +99,8 @@ module Samagotchi
     attr_reader :default_model
 
     # @return [Symbol] :idle_exit, :exit_requested when a client asked it
-    #   to exit (Bridge POST /exit), :stopped when the session was stopped
+    #   to exit (Bridge POST /exit), :restart when it asked for a restart
+    #   (the caller starts a new worker), :stopped when the session was stopped
     #   (chi stop), :crashed when the loop raised (the session is marked
     #   errored); SessionManager.run_session_loop turns it into the exit
     def run
@@ -154,7 +158,8 @@ module Samagotchi
         engine: @engine, bridge: @bridge,
         timeout_minutes: @idle_exit_minutes || SessionManager.config_idle_exit_minutes,
         input_pending: -> { !@command_queue.empty? || !SessionInbox.find_new_input_files(@session_dir).empty? },
-        awaiting_continue: -> { @turn_flow.awaiting_continue? }
+        awaiting_continue: -> { @turn_flow.awaiting_continue? },
+        running_tasks: -> { Tools::TaskRuntime.running_created_in(@engine.messages_checkpoint) }
       )
 
       begin
@@ -188,7 +193,7 @@ module Samagotchi
           if input_files.empty?
             next if run_due_reminders
             return left(:idle_exit) if @idle_exit.due? && leave_idle
-            return left(:exit_requested) if @exit_requested && leave_on_request
+            return left(@exit_restart ? :restart : :exit_requested) if @exit_requested && leave_on_request
 
             @waker.wait(@poll_interval)
             next
@@ -581,17 +586,20 @@ module Samagotchi
 
     # Bridge POST /exit, on a Bridge thread with the event log held.
     # +delete+: the session is deleted after (/exit --delete), so no recap.
+    # +restart+: a new worker takes over (on the newest chi installed), so
+    # WorkerIdleExit#hold_for_restart's rules, and no recap or discard.
     # @return [Symbol, nil] what keeps the worker up, nil when it will leave
-    def exit_request(client_id, delete: false)
+    def exit_request(client_id, delete: false, restart: false)
       # The Bridge serves before the idle-exit policy exists.
       return :starting unless @idle_exit
 
-      hold = @idle_exit.hold_for_request(requester: client_id)
+      hold = restart ? @idle_exit.hold_for_restart : @idle_exit.hold_for_request(requester: client_id)
       return hold if hold
 
       @exit_requested = true
       @exit_requested_by = client_id
-      @exit_deletes = delete
+      @exit_deletes = delete && !restart
+      @exit_restart = restart
       @waker.wake
       nil
     end
@@ -604,16 +612,21 @@ module Samagotchi
     # @return [Boolean] false when something came in since the request
     def leave_on_request
       @engine.synchronize_events do
-        hold = @idle_exit.hold_for_request(requester: @exit_requested_by, streams: false)
+        hold = if @exit_restart
+                 @idle_exit.hold_for_restart
+               else
+                 @idle_exit.hold_for_request(requester: @exit_requested_by, streams: false)
+               end
         if hold
           @exit_requested = nil
+          @exit_restart = false
           Log.info(:worker, "exit_held", reason: hold)
           next false
         end
 
         @bridge&.stop
         @engine.stop_idle
-        Log.info(:worker, "exit_requested", by: @exit_requested_by || "a client")
+        Log.info(:worker, @exit_restart ? "restart_requested" : "exit_requested", by: @exit_requested_by || "a client")
         true
       end
     end
@@ -623,7 +636,11 @@ module Samagotchi
     #   stopped by now, and nothing waits on this (the TUI has detached). A
     #   `chi send` meanwhile is picked up after the exit (run_session_loop);
     #   a `chi --attach` finds no Bridge until then.
+    # A restart keeps even an empty session (a new worker takes it over at
+    # once) and leaves the recap to the conversation's next real pause.
     def left(result)
+      return result if result == :restart
+
       @discard = empty_session?
       write_recap_on_leave unless @discard || (result == :exit_requested && @exit_deletes)
       result

data/lib/samagotchi/worker_idle_exit.rb

@@ -18,7 +18,8 @@ module Samagotchi
   #
   # A client can also ask the worker to exit now (`/exit` in the attached
   # TUI, Bridge POST /exit): #hold_for_request applies the same rules without
-  # the timeout and leaves out the asking client's own stream.
+  # the timeout and leaves out the asking client's own stream. A restart
+  # (POST /exit restart: true) has its own rules, #hold_for_restart.
   class WorkerIdleExit
     # @param engine [Engine] #turn_running?, #last_activity_at, #reminder_store
     # @param bridge [Bridge, nil] #open_streams, #last_client_activity_at; nil
@@ -26,14 +27,17 @@ module Samagotchi
     # @param timeout_minutes [Numeric, nil] 0 or nil: never exit
     # @param input_pending [#call] true while input files wait
     # @param awaiting_continue [#call] true while a continue offer waits
+    # @param running_tasks [#call] the background tasks this conversation
+    #   started that still run (Tools::TaskRuntime.running_created_in)
     # @param clock [#call] monotonic seconds, the Engine's and Bridge's clock
     def initialize(engine:, bridge:, timeout_minutes:, input_pending:, awaiting_continue: -> { false },
-                   clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+                   running_tasks: -> { [] }, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       @engine = engine
       @bridge = bridge
       @timeout = timeout_minutes.to_f * 60
       @input_pending = input_pending
       @awaiting_continue = awaiting_continue
+      @running_tasks = running_tasks
       @clock = clock
       @started_at = clock.call
     end
@@ -78,6 +82,31 @@ module Samagotchi
       nil
     end
 
+    # What keeps the worker from restarting now (a client asked: POST /exit
+    # restart: true), or nil. A restart drops what lives only in this
+    # process, so whatever would be lost or cut holds it: a question or
+    # approval waiting (a turn's), a /btw (or another anytime command)
+    # running, a delegate's approval relay this worker still answers for,
+    # background tasks this conversation started (their output and end are
+    # this worker's to report). Clients' streams don't hold: a web tab
+    # reconnects on the new worker's bridge_up, an attached terminal finds
+    # the new worker's Bridge.
+    # @return [Symbol, nil] :turn_running, :input_queued, :continue_offered,
+    #   :question_pending, :reminders, :command_running, :relays_open or
+    #   :background_tasks
+    def hold_for_restart
+      return :turn_running if @engine.turn_running?
+      return :input_queued if @input_pending.call
+      return :continue_offered if @awaiting_continue.call
+      return :question_pending if @engine.pending_question
+      return :reminders if @engine.reminder_store&.any?
+      return :command_running if @engine.anytime_running?
+      return :relays_open if @engine.relay_desk.active?
+      return :background_tasks if @running_tasks.call.any?
+
+      nil
+    end
+
     # @return [Float] seconds since the latest activity of any kind
     def idle_seconds
       last = [@started_at, @engine.last_activity_at, @bridge&.last_client_activity_at].compact.max

data/lib/samagotchi/worker_sidecar.rb

@@ -8,11 +8,12 @@ require_relative "atomic_file"
 module Samagotchi
   # A worker's bridge.json in its session directory: how clients reach its
   # Bridge (port, bind), when it started (a new worker behind the same
-  # "worker" owner), the chi it runs (chi update) and the input-file format
-  # it reads (SessionInbox::INPUT_FORMAT). The Bridge writes it on start
+  # "worker" owner), the chi it runs (chi update, the web's stale-worker
+  # badge), the input-file format it reads (SessionInbox::INPUT_FORMAT) and
+  # what else it can do (Bridge::FEATURES). The Bridge writes it on start
   # and removes it on stop; one a dead worker left stays until a client's
   # probe finds its port closed (.live with unlink: true).
-  class WorkerSidecar < Data.define(:port, :bind, :session_id, :started_at, :version, :input_format)
+  class WorkerSidecar < Data.define(:port, :bind, :session_id, :started_at, :version, :input_format, :features)
     FILE = "bridge.json"
     # Seconds a liveness probe waits for the port to take a connect.
     PROBE_TIMEOUT = 0.2
@@ -27,7 +28,8 @@ module Samagotchi
 
       port = data["port"]
       new(port: port.respond_to?(:to_i) ? port.to_i : 0, bind: data["bind"], session_id: data["session_id"],
-          started_at: data["started_at"], version: data["version"], input_format: data["input_format"])
+          started_at: data["started_at"], version: data["version"], input_format: data["input_format"],
+          features: Array(data["features"]).map(&:to_s))
     rescue JSON::ParserError, SystemCallError
       nil
     end
@@ -61,7 +63,7 @@ module Samagotchi
     # @return [Integer, nil] .live's port
     def self.live_port(session_dir, unlink:, host: "127.0.0.1") = live(session_dir, unlink: unlink, host: host)&.port
 
-    def initialize(port:, bind: nil, session_id: nil, started_at: nil, version: nil, input_format: nil) = super
+    def initialize(port:, bind: nil, session_id: nil, started_at: nil, version: nil, input_format: nil, features: []) = super
 
     # Written whole or not at all; input_format only when it names one.
     def write(session_dir)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -252,6 +252,7 @@ files:
 - lib/samagotchi/idle_scheduler.rb
 - lib/samagotchi/image_store.rb
 - lib/samagotchi/installed_gem.rb
+- lib/samagotchi/installed_versions.rb
 - lib/samagotchi/iteration_limit.rb
 - lib/samagotchi/kernel_loop.rb
 - lib/samagotchi/launch_mode.rb
@@ -352,6 +353,7 @@ files:
 - lib/samagotchi/terminal_ui/input_support.rb
 - lib/samagotchi/terminal_ui/line_reader.rb
 - lib/samagotchi/terminal_ui/live_region.rb
+- lib/samagotchi/terminal_ui/one_shot_sink.rb
 - lib/samagotchi/terminal_ui/plain_surface.rb
 - lib/samagotchi/terminal_ui/question_prompt.rb
 - lib/samagotchi/terminal_ui/question_slot.rb
@@ -362,6 +364,7 @@ files:
 - lib/samagotchi/terminal_ui/status_row.rb
 - lib/samagotchi/terminal_ui/surface.rb
 - lib/samagotchi/terminal_ui/thinking_line.rb
+- lib/samagotchi/terminal_ui/version_lines.rb
 - lib/samagotchi/text_diff.rb
 - lib/samagotchi/thinking.rb
 - lib/samagotchi/thinking_ticker.rb