samagotchi 0.59.0 → 0.61.0

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

@@ -21,6 +21,7 @@
 // chrome (CSS :has), so a plain answer streams like today's bubble, and is
 // removed at the end: the answer bubble takes its place.
 import { html, nothing, render } from "./vendor/lit-html.js";
+import { setAnswerRefs } from "./answer_refs.js";
 import { leavesBlock } from "./card.js";
 import { copySourceAttr } from "./copy.js";
 import { escapeHtml, failedTurnText, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
@@ -779,10 +780,12 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
       : "";
   };
   // The timing line after the bubble, not in it: where the live view
-  // leaves it at the turn's end.
-  const answerHtml = (m, timing) => {
+  // leaves it at the turn's end. +at+: the message's index, for its refs
+  // (data-answer-at, gone before the nodes are returned).
+  const answerHtml = (at, timing) => {
+    const m = items[at];
     const { body, renderedMarkdown } = messageBodyHtml(m);
-    return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
+    return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}" data-answer-at="${at}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
   };
   // A user's line, labelled when chi brought it in (a delegate report). A
   // `!cmd`'s saved message (the worker's "!(<command>)\n<output>") renders
@@ -799,14 +802,14 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
     const j = items.findIndex((m, k) => k > i && m?.role === "assistant" && String(m.content ?? "").trim());
     if (j < 0 || j === group.answer || items.slice(i + 1, j).some((m) => m?.role === "user" && !m.merged)) return "";
     const { body, renderedMarkdown } = messageBodyHtml(items[j]);
-    return `<div class="bubble output report-reply${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(items[j], renderedMarkdown)}>${body}</div>`;
+    return `<div class="bubble output report-reply${renderedMarkdown ? " markdown" : ""}" data-answer-at="${j}"${copySourceAttr(items[j], renderedMarkdown)}>${body}</div>`;
   };
   const steerHtml = (i, bubble) => steerRowHtml({ source: items[i].source, text: items[i].content }, { bubble });
   const parts = [];
   for (const group of turnGroups(items, timing)) {
     if (group.kind === "note") { parts.push(`<div class="bubble note">${noteHtml(items[group.i])}</div>`); continue; }
     if (group.kind === "steer") { parts.push(steerHtml(group.i, true)); continue; }
-    if (group.kind === "answer") { parts.push(answerHtml(items[group.answer], "")); continue; }
+    if (group.kind === "answer") { parts.push(answerHtml(group.answer, "")); continue; }
     const prompt = items[group.user];
     // A context wake turn starts with its note.
     parts.push(prompt.role === "note" ? `<div class="bubble note">${noteHtml(prompt)}</div>` : userHtml(prompt));
@@ -846,11 +849,18 @@ export function turnHistoryNodes(items, timing, { thumbs }) {
     // A turn with no answer (canceled, or running: no record yet) shows its
     // timing after its prompt and steps, where the live view leaves it.
     else if (group.answer === null) parts.push(timingHtml(group));
-    else parts.push(answerHtml(items[group.answer], timingHtml(group)));
+    else parts.push(answerHtml(group.answer, timingHtml(group)));
     // A canceled turn ends with its cancel line, a failed one whose steps
     // stayed with its failure line, as the live view left them.
     parts.push(cancelLineHtml(group.record, escapeHtml));
     parts.push(failedLineHtml(group.record));
   }
-  return fragmentOf(parts);
+  const out = fragmentOf(parts);
+  // Each answer bubble knows its message's refs (answer_refs.js; the
+  // page pairs them after the render), the index stays out of the DOM.
+  for (const bubble of out.querySelectorAll("[data-answer-at]")) {
+    setAnswerRefs(bubble, items[Number(bubble.dataset.answerAt)]?.display_refs);
+    bubble.removeAttribute("data-answer-at");
+  }
+  return out;
 }

data/lib/samagotchi/worker.rb

@@ -12,10 +12,12 @@ require_relative "steer"
 require_relative "worker_idle_exit"
 require_relative "worker_wakes"
 require_relative "worker_inbound"
+require_relative "worker_signals"
 require_relative "session_manager"
 require_relative "archive_store"
 require_relative "log"
 require_relative "turn_flow"
+require_relative "turn_checkpoint"
 require_relative "llm/errors"
 require_relative "continue_offer"
 require_relative "iteration_limit"
@@ -52,6 +54,13 @@ module Samagotchi
   # /continue) run on the loop between turns, before any queued prompt. One
   # taken while a turn runs (at an iteration boundary, or right after the
   # turn) is refused as busy.
+  #
+  # A TERM, HUP or INT (WorkerSignals, trapped in a spawned worker only)
+  # stops the running turn as a Stop does (reason :signal), the turn's
+  # work is saved as after any Stop, and the worker leaves (:signal) taking
+  # no new work. A turn that hasn't ended SIGNAL_GRACE seconds after the
+  # signal is cut: the session is saved as it is and the signal raised in
+  # the loop's thread, as Ruby's default would (the teardown still runs).
   class Worker
     FALLBACK_TICK_SECONDS = 5
     # A worker just started runs no wake turn for delegate reports this
@@ -64,6 +73,18 @@ module Samagotchi
     BUSY_OUTPUT = "busy: wait for the turn to end"
     # !rollback mid-turn would mean "the turn I'm in".
     ROLLBACK_BUSY_OUTPUT = "busy: Ctrl-C the turn first, then !rollback"
+    # How long a signalled worker's turn has to end (it is canceled at once,
+    # and again every SIGNAL_RETRY until it ends: a signal that lands just
+    # before the turn begins finds none to cancel).
+    SIGNAL_GRACE = 3.0
+    # A second signal, or a TERM after `chi sessions stop` marked the
+    # session stopped (that stop already canceled over the Bridge and waits
+    # only seconds for the lock): this much.
+    SIGNAL_SHORT_GRACE = 0.5
+    SIGNAL_RETRY = 0.1
+    # After the grace ran out and the signal was raised: the process ends
+    # this much later at the latest (a teardown that hangs).
+    SIGNAL_HARD_EXIT = 10.0
 
     # Wakes the worker loop. Whoever queues work writes it first and wakes
     # after, and #wait drains every wake before the loop looks for work: a
@@ -90,7 +111,12 @@ module Samagotchi
 
     # @param idle_exit_minutes [Numeric, nil] nil: session.idle_exit_minutes
     # @param poll_interval [Numeric, nil] seconds between fallback ticks
-    def initialize(session_id:, state_dir:, session_dir:, idle_exit_minutes: nil, poll_interval: nil)
+    # @param signals [WorkerSignals, WorkerSignals::None] the process's
+    #   trapped signals (SessionManager.run_session_loop); none by default
+    # @param signal_grace [Array(Numeric, Numeric, Numeric)] the grace, the
+    #   short grace and the hard exit's delay (specs shorten them)
+    def initialize(session_id:, state_dir:, session_dir:, idle_exit_minutes: nil, poll_interval: nil,
+                   signals: WorkerSignals::NONE, signal_grace: [SIGNAL_GRACE, SIGNAL_SHORT_GRACE, SIGNAL_HARD_EXIT])
       @session_id = session_id
       @state_dir = state_dir
       @session_dir = session_dir
@@ -116,6 +142,20 @@ module Samagotchi
       @asked_parent = false
       @owes_parent = false
       @initial_turn = false
+      @signals = signals
+      @signal_grace, @signal_short_grace, @signal_hard_exit = signal_grace
+      # Set as the loop starts, and as it returns (or raises): a signal's
+      # grace runs out only in between.
+      @loop_started = false
+      @left_loop = false
+      @signal_mutex = Mutex.new
+      @grace_expired = false
+      # The running turn has ended (its end event) and its after_turn hooks
+      # run: a signal's grace waits for them (#signalled).
+      @turn_ending = false
+      # The worker's own saves and a signal's (#signal_grace_expired), one
+      # at a time.
+      @save_mutex = Mutex.new
     end
 
     # Whether the session was empty as the worker left it, so the caller
@@ -135,30 +175,46 @@ module Samagotchi
     # @return [Symbol] :idle_exit, :exit_requested when a client asked it
     #   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
+    #   (chi stop), :signal when a signal stopped it (WorkerSignals),
+    #   :crashed when the loop raised (the session is marked errored);
+    #   SessionManager.run_session_loop turns it into the exit
     def run
+      # The thread a signal's expired grace raises in (the main thread in a
+      # worker process).
+      @run_thread = Thread.current
+      @signals.on_signal { |name, count| signalled(name, count) }
       start
       serve
-      begin
-        # A session stopped before this worker took the lock (e.g. a stop
-        # right after create) must not run its initial prompt.
-        return :stopped if stopped_on_disk?
-
-        start_background
-        loop do
-          leaving = pass
-          return leaving if leaving
-        end
+      # That raise lands in the loop only (#signal_grace_expired arms once
+      # it started, and never after it left): the teardown always runs
+      # whole, a raise already on its way waits until it is done.
+      Thread.handle_interrupt(SignalException => :never) do
+        Thread.handle_interrupt(SignalException => :immediate) { run_loop }
       rescue StandardError => e
         crashed(e)
       ensure
+        @signal_mutex.synchronize { @left_loop = true }
         teardown
       end
     end
 
     private
 
+    # @return [Symbol] what #run returns
+    def run_loop
+      @signal_mutex.synchronize { @loop_started = true }
+      # A session stopped before this worker took the lock (e.g. a stop
+      # right after create) must not run its initial prompt.
+      return :stopped if stopped_on_disk?
+      return signal_leave if signalled?
+
+      start_background
+      loop do
+        leaving = pass
+        return leaving if leaving
+      end
+    end
+
     # The session, its Engine and what runs its turns, before anyone can
     # reach it.
     def start
@@ -171,7 +227,10 @@ module Samagotchi
       ChildMove.adopt(@session_id, state_dir: @state_dir)
       @session = Session.load(@session_id, state_dir: @state_dir)
       drop_dead_question
+      # The running turn, on disk at its iteration boundaries.
+      @checkpoint = TurnCheckpoint.new(session: @session, state_dir: @state_dir)
       @engine = build_engine
+      settle_interrupted_turn
       # Before the Bridge serves anything: a UI joining a resumed worker's
       # stream gets the session's history and status in its snapshot, not
       # an empty session until the first turn.
@@ -200,8 +259,12 @@ module Samagotchi
         if Events::TURN_END.include?(event[:type])
           @turn_end_seq = event[:event_seq]
           @turn_end_type = event[:type]
+          @turn_ending = true
+        end
+        if event[:type] == :turn_started
+          @turn_id = event[:turn_id]
+          @turn_ending = false
         end
-        @turn_id = event[:turn_id] if event[:type] == :turn_started
         ring_question(event) if event[:type] == :question_requested
       })
       # This session's own delegate children's news (rings in children/).
@@ -268,6 +331,9 @@ module Samagotchi
     # next pass looks again; with none, #idle_pass.
     # @return [Symbol, nil] what #run returns as the worker leaves, nil to go on
     def pass
+      # A signalled worker takes no new work.
+      return signal_leave if signalled?
+
       # Check if the session was externally marked as stopped. Not
       # stopped_on_disk?, which reads a vanished file as "not stopped":
       # a session file deleted under a running worker crashes it here
@@ -316,8 +382,8 @@ module Samagotchi
     # @return [nil]
     def run_input_files(input_files)
       input_files.sort.each do |input_file|
-        # A stop between two queued turns leaves the rest queued.
-        break if stopped_on_disk?
+        # A stop (or a signal) between two queued turns leaves the rest queued.
+        break if signalled? || stopped_on_disk?
 
         # Commands that came before this file (D1: a queued /model X sent
         # before this prompt, a command an earlier file carried) run first.
@@ -367,6 +433,7 @@ module Samagotchi
         # (re)spawn.
         memories: @session.preloaded_memory_names,
         muted_memories: @session.muted_memory_names,
+        appended_prompt_files: @session.appended_prompt_files,
         reminders: {
           callback: lambda { |due_names|
             # A reminder is due: the loop runs a reminder turn for it once
@@ -384,6 +451,17 @@ module Samagotchi
       engine
     end
 
+    # A turn an earlier worker died in (TurnCheckpoint's mark in the file):
+    # ended now as canceled, with its note, and saved, before the Bridge
+    # serves the session (TurnCheckpoint.settle).
+    def settle_interrupted_turn
+      mark = TurnCheckpoint.settle(@session)
+      return unless mark
+
+      Log.info(:worker, "interrupted_turn_settled", turn_id: mark.id, iteration: mark.iteration, at: mark.at)
+      save_or_log(:interrupted_turn) { @session.save(state_dir: @state_dir) }
+    end
+
     # A question saved by a worker that died while it waited (an
     # ask_user_question, an approval, a hook's question): the turn that
     # asked is gone, so nobody can answer it, and left in the file it
@@ -571,7 +649,8 @@ module Samagotchi
     # @return [Boolean] whether any command ran
     def run_queued_commands
       ran = false
-      while (command = next_ready_command)
+      # A signalled worker runs no more (a /continue would start a turn).
+      while !signalled? && (command = next_ready_command)
         run_command(command)
         ran = true
       end
@@ -821,6 +900,7 @@ module Samagotchi
       @reporting_turn = reports_to_parent?(turn_args[:origin])
       restores = @turn_flow.restores
       begin
+        @checkpoint.begin_turn(prompt: prompt)
         @session.status = Session::STATUS_RUNNING
         # A continue that moved this session to the chain's new link wrote
         # the new parent beside it (Session::PARENT_FILE): this turn's
@@ -839,6 +919,8 @@ module Samagotchi
           Log.warn(:worker, "turn_not_begun", error: e.class.name, msg: e.message)
         end
       ensure
+        # Ended (or never begun): the saves write the session's own messages.
+        @checkpoint.end_turn
         refuse_queued_commands
       end
       yield result, error
@@ -994,6 +1076,9 @@ module Samagotchi
                 reports.map(&:line)
         # A wake turn starts with its first line, whoever sent it.
         lines[0] = lines[0].with(mark: mark) if mark && lines.any?
+        # The turn so far, with what this boundary merges (its input files
+        # are gone now), on disk at most every TurnCheckpoint::INTERVAL.
+        @checkpoint.boundary(@engine.live_conversation, merging: lines, turn_id: @turn_id)
         lines
       end
     end
@@ -1126,11 +1211,74 @@ module Samagotchi
       SessionManager.stopped_on_disk?(@session_id, state_dir: @state_dir)
     end
 
-    # Save the session unless it was stopped meanwhile: the stop (chi stop,
-    # from another process) saved its status, and this save would write
-    # the worker's over it.
+    # Save the session, a stopped one too: a stop is the marker file
+    # (Session.mark_stopped), which every load reads over the saved status,
+    # so this save can't hide it, and the turn the stop canceled is kept.
     def save_session
-      @session.save(state_dir: @state_dir) unless stopped_on_disk?
+      @save_mutex.synchronize { @session.save(state_dir: @state_dir) }
+    end
+
+    def signalled? = !@signals.signal.nil?
+
+    # @return [Symbol] :stopped when the session was stopped too (chi
+    #   sessions stop TERMs its worker), else :signal
+    def signal_leave
+      Session.stopped_marker?(@session_id, state_dir: @state_dir) ? :stopped : :signal
+    end
+
+    # A signal (WorkerSignals#fire), on a thread of its own: the loop wakes
+    # (an idle worker leaves at once), the running turn is canceled as a
+    # Stop (again every SIGNAL_RETRY, until the loop has left), and when
+    # the grace runs out first, #signal_grace_expired. A turn that has
+    # ended and runs its after_turn hooks (which store the answer's display
+    # and refs) is no longer canceled, and gets until SIGNAL_HARD_EXIT
+    # past the grace, the worker's own end of the turn (its saves, after
+    # the turn stopped running) too: the loop leaves next. A grace that runs out before the loop started waits
+    # for it (the loop's first look leaves). A signal after the loop left
+    # (the teardown, the caller's last steps) only brings the hard exit.
+    def signalled(name, count)
+      Log.info(:worker, "signal", signal: name, count: count, turn_running: @engine&.turn_running? || false)
+      return signal_hard_exit if @left_loop
+
+      @waker.wake
+      short = count > 1 || Session.stopped_marker?(@session_id, state_dir: @state_dir)
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      deadline = now + (short ? @signal_short_grace : @signal_grace)
+      hooks_deadline = deadline + @signal_hard_exit
+      ended = false
+      until @left_loop
+        running = @engine&.turn_running?
+        ended ||= running && @turn_ending
+        @engine.cancel_current_turn!(:signal) if running && !ended
+        break if @loop_started && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= (ended ? hooks_deadline : deadline)
+
+        sleep(SIGNAL_RETRY)
+      end
+      signal_grace_expired(name) unless @left_loop
+    rescue StandardError => e
+      Log.warn(:worker, "signal_failed", signal: name, error: e.class.name, msg: e.message)
+    end
+
+    # The process ends SIGNAL_HARD_EXIT from now at the latest.
+    def signal_hard_exit
+      sleep(@signal_hard_exit)
+      @signals.hard_exit
+    end
+
+    # The turn didn't end in time (a tool that ignores the cancel, slow
+    # after_turn hooks): the session is saved as it is now (a turn that has
+    # ended: with it), and the signal raised in the loop's thread, so
+    # Worker#run's teardown and the lock's release still run. The process
+    # ends SIGNAL_HARD_EXIT later at the latest. Once, whatever the signals.
+    def signal_grace_expired(name)
+      expired = @signal_mutex.synchronize { !@grace_expired && !@left_loop && (@grace_expired = true) }
+      return unless expired
+
+      Log.warn(:worker, "signal_grace_expired", signal: name, turn_running: @engine&.turn_running? || false)
+      save_or_log(:signal) { save_session }
+      # Not once the loop has left (it may have, during the save).
+      @signal_mutex.synchronize { @run_thread&.raise(SignalException.new(name)) unless @left_loop }
+      signal_hard_exit
     end
   end
 end

data/lib/samagotchi/worker_signals.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # TERM, HUP and INT in a worker process: the running turn stops as a Stop
+  # does (reason :signal), is saved, and the worker leaves (Worker#run
+  # returns :signal). SessionManager.run_session_loop installs the traps in
+  # a spawned worker only (WORKER_PROCESS_ENV), never in a process that runs
+  # the loop in-process (the specs, which fire #fire directly).
+  #
+  # A trap handler may take no lock (Mutex#lock raises ThreadError in trap
+  # context) and should do no IO: the trap only records the signal and
+  # starts a thread, which calls the worker's handler (#on_signal).
+  #
+  # Ruby's default for these signals raised SignalException in the main
+  # thread, mid-turn: the turn skipped every end-of-turn path and nothing of
+  # it reached the session file.
+  class WorkerSignals
+    SIGNALS = %w[TERM HUP INT].freeze
+
+    # Nothing trapped and nothing fires: Worker.new's default (specs, and
+    # any caller that isn't a spawned worker).
+    class None
+      def on_signal(&) = nil
+      def signal = nil
+      def count = 0
+      def hard_exit = nil
+      def restore! = nil
+    end
+    NONE = None.new.freeze
+
+    # @return [String, nil] the first signal received ("TERM"), nil before one
+    attr_reader :signal
+
+    # @param hard_exit [#call] the last resort when the worker hasn't left
+    #   long after the signal (exit! in a real worker)
+    def initialize(hard_exit: -> { Process.exit!(1) })
+      @signal = nil
+      @count = 0
+      @handler = nil
+      @hard_exit = hard_exit
+      @previous = {}
+    end
+
+    # How many signals came (a second one skips the grace).
+    attr_reader :count
+
+    # The worker's handler, called on a thread of its own with the signal
+    # name and the count, once per signal.
+    def on_signal(&handler)
+      @handler = handler
+    end
+
+    # Trap SIGNALS in this process (the previous handlers kept for #restore!).
+    # @return [self]
+    def install!
+      SIGNALS.each { |name| @previous[name] = Signal.trap(name) { fire(name) } }
+      self
+    end
+
+    # The handlers from before #install!.
+    def restore!
+      @previous.each { |name, handler| Signal.trap(name, handler || "DEFAULT") }
+      @previous.clear
+    end
+
+    # What a trap does (and what specs call): record +name+ and run the
+    # handler on its own thread. Safe in trap context: no lock, no IO.
+    # @return [Thread, nil] the handler's thread
+    def fire(name)
+      @signal ||= name
+      @count += 1
+      handler = @handler
+      count = @count
+      return nil unless handler
+
+      Thread.new { handler.call(name, count) }
+    end
+
+    def hard_exit = @hard_exit.call
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.59.0
+  version: 0.61.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -150,6 +150,7 @@ files:
 - lib/samagotchi/analytics_file.rb
 - lib/samagotchi/answer_command.rb
 - lib/samagotchi/answer_display.rb
+- lib/samagotchi/answer_refs.rb
 - lib/samagotchi/answer_tail.rb
 - lib/samagotchi/archive_store.rb
 - lib/samagotchi/atomic_file.rb
@@ -178,6 +179,8 @@ files:
 - lib/samagotchi/broadcast_command.rb
 - lib/samagotchi/bundle_command.rb
 - lib/samagotchi/bundle_needs.rb
+- lib/samagotchi/bundles/agents-md/manifest.yml
+- lib/samagotchi/bundles/agents-md/plugin.rb
 - lib/samagotchi/bundles/btw/manifest.yml
 - lib/samagotchi/bundles/btw/plugin.rb
 - lib/samagotchi/bundles/check-in/manifest.yml
@@ -306,6 +309,7 @@ files:
 - lib/samagotchi/image_store.rb
 - lib/samagotchi/installed_gem.rb
 - lib/samagotchi/installed_versions.rb
+- lib/samagotchi/interrupted_turn.rb
 - lib/samagotchi/iteration_limit.rb
 - lib/samagotchi/kernel_loop.rb
 - lib/samagotchi/last_turn.rb
@@ -392,6 +396,7 @@ files:
 - lib/samagotchi/process_group.rb
 - lib/samagotchi/project_scope.rb
 - lib/samagotchi/prompt.rb
+- lib/samagotchi/prompt_files.rb
 - lib/samagotchi/prompt_history.rb
 - lib/samagotchi/prompt_literal_guard.rb
 - lib/samagotchi/prompt_note.rb
@@ -403,6 +408,7 @@ files:
 - lib/samagotchi/recap_setup.rb
 - lib/samagotchi/recap_store.rb
 - lib/samagotchi/redacted_inspect.rb
+- lib/samagotchi/ref.rb
 - lib/samagotchi/relay.rb
 - lib/samagotchi/relay_desk.rb
 - lib/samagotchi/relay_verifier.rb
@@ -503,6 +509,7 @@ files:
 - lib/samagotchi/tools/tool_path.rb
 - lib/samagotchi/tools/web_fetch.rb
 - lib/samagotchi/tools/write.rb
+- lib/samagotchi/turn_checkpoint.rb
 - lib/samagotchi/turn_flow.rb
 - lib/samagotchi/turn_note.rb
 - lib/samagotchi/turn_state.rb
@@ -526,6 +533,7 @@ files:
 - lib/samagotchi/web/public/annotate_bar.js
 - lib/samagotchi/web/public/annotate_presets.js
 - lib/samagotchi/web/public/annotations.js
+- lib/samagotchi/web/public/answer_refs.js
 - lib/samagotchi/web/public/app.js
 - lib/samagotchi/web/public/card.js
 - lib/samagotchi/web/public/chains.js
@@ -542,6 +550,7 @@ files:
 - lib/samagotchi/web/public/data.js
 - lib/samagotchi/web/public/diff_view.js
 - lib/samagotchi/web/public/families_view.js
+- lib/samagotchi/web/public/favicon.svg
 - lib/samagotchi/web/public/format.js
 - lib/samagotchi/web/public/hold.js
 - lib/samagotchi/web/public/images.js
@@ -599,6 +608,7 @@ files:
 - lib/samagotchi/worker_idle_exit.rb
 - lib/samagotchi/worker_inbound.rb
 - lib/samagotchi/worker_sidecar.rb
+- lib/samagotchi/worker_signals.rb
 - lib/samagotchi/worker_wakes.rb
 - lib/samagotchi/yaml_lines.rb
 homepage: https://github.com/dm1try/samagotchi