samagotchi 0.30.0 → 0.32.0

data/lib/samagotchi/worker.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "securerandom"
+require "time"
 
+require_relative "config"
 require_relative "events"
 require_relative "session"
 require_relative "session_inbox"
@@ -17,6 +20,9 @@ require_relative "continue_offer"
 require_relative "iteration_limit"
 require_relative "session_commands"
 require_relative "model_profile"
+require_relative "child_reports"
+require_relative "context_absorber"
+require_relative "context_poller"
 require_relative "tools/task_runtime"
 
 module Samagotchi
@@ -45,6 +51,14 @@ module Samagotchi
   # turn) is refused as busy.
   class Worker
     FALLBACK_TICK_SECONDS = 5
+    # A worker just started runs no wake turn for delegate reports this
+    # long: a worker spawned for a message (chi send to a stopped parent)
+    # gets it over the Bridge a moment after it starts, and that message's
+    # turn goes first (the reports join it).
+    WAKE_START_GRACE = 2.0
+    # One context wake per source in this long (D5): later changes inside
+    # it arrive as notes.
+    CONTEXT_WAKE_WINDOW = 600
     # How much of a command's output goes into its :command_ran.
     COMMAND_OUTPUT_LIMIT = 4096
     BUSY_OUTPUT = "busy: wait for the turn to end"
@@ -89,6 +103,25 @@ module Samagotchi
       @discard = false
       # The exit asked for is a restart (POST /exit restart: true).
       @exit_restart = false
+      # The lines the running turn's drain merged ([prompt, origin]), for a
+      # failed prompt turn to hand back; reset as each turn begins.
+      @merged_this_turn = []
+      # A delegate child's side (ChildRing): whether the running turn is
+      # its parent's (it rings when it ends), whether that turn rang a
+      # question, and whether the next turn rings whatever its origin (it
+      # follows a question the parent was rung about: D10).
+      @reporting_turn = false
+      @asked_parent = false
+      @owes_parent = false
+      @initial_turn = false
+      # A parent's side: turns run for delegate reports since the last human
+      # input (session.max_wakes), whether a failed one paused them until
+      # then, whether the budget notice went out, and the reports a wake
+      # turn's first boundary hands over.
+      @wakes_in_a_row = 0
+      @wakes_paused = false
+      @budget_noticed = false
+      @wake_reports = nil
     end
 
     # Whether the session was empty as the worker left it, so the caller
@@ -96,6 +129,12 @@ module Samagotchi
     # checks again then).
     def discard? = @discard
 
+    # Whether delegate reports wait that an idle parent runs a turn for
+    # (#wake_state): SessionManager.run_session_loop starts a new worker
+    # for them after this one leaves. Reports the budget or a failure held
+    # back wait for the next human input instead.
+    def wake_due? = wake_state == :due
+
     # What a new session starts on (and /model resets to); nil before #run.
     attr_reader :default_model
 
@@ -105,6 +144,7 @@ module Samagotchi
     #   (chi stop), :crashed when the loop raised (the session is marked
     #   errored); SessionManager.run_session_loop turns it into the exit
     def run
+      @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @session = Session.load(@session_id, state_dir: @state_dir)
       drop_dead_question
       @engine = build_engine
@@ -114,7 +154,7 @@ module Samagotchi
       @engine.session = @session
       # Input already waiting in the inbox starts the next turn at once: no
       # turn-end warm-up then.
-      @engine.next_turn_waiting = -> { SessionInbox.find_new_input_files(@session_dir).any? }
+      @engine.next_turn_waiting = -> { SessionInbox.find_new_input_files(@session_dir).any? || wake_due? }
       @turn_flow = TurnFlow.new(engine: @engine)
       # Its question's answer is queued as the matching /continue (the
       # Bridge exists by the time anyone answers).
@@ -131,7 +171,14 @@ module Samagotchi
       @turn_end_seq = 0
       @engine.subscribe(observer: lambda { |event|
         @turn_end_seq = event[:event_seq] if Events::TURN_END.include?(event[:type])
+        @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/).
+      @child_reports = ChildReports.new(session_id: @session_id, state_dir: @state_dir)
+      # Its attached context's notes (ContextSources).
+      @context_absorber = ContextAbsorber.new(session_id: @session_id, state_dir: @state_dir,
+                                              project_root: @session.project_root)
       # /model's default is the config's, as in the REPL; the Engine started
       # on the session's model.
       @default_model = ModelProfile.required_model_name(nil)
@@ -175,6 +222,11 @@ module Samagotchi
         # the background, shown by the UIs; a turn waits only for the ones
         # that bring tools.
         @engine.start_init_tasks!
+        # Attached context's commands, in the background; a new text wakes
+        # the loop to absorb it. Not activity: the idle exit stops it.
+        @context_poller = ContextPoller.new(session_id: @session_id, state_dir: @state_dir,
+                                            project_root: @session.project_root, cwd: @session.working_directory,
+                                            on_change: -> { @waker.wake }).start
         loop do
           # Check if the session was externally marked as stopped. Not
           # stopped_on_disk?, which reads a vanished file as "not stopped":
@@ -187,20 +239,24 @@ module Samagotchi
           next if run_queued_commands
 
           # Between turns, so the next turn (the first one too) sees them.
+          # A change that asks to wake may start a turn here (C4), but not
+          # ahead of an exit or restart a client asked for: it is a note then.
           absorb_notes
+          next if absorb_context(wake: nothing_queued? && !@exit_requested)
 
           if (prompt = take_initial_prompt)
-            run_prompt(prompt, nil) unless initial_command(prompt)
+            run_initial_prompt(prompt) unless initial_command(prompt)
             next
           end
 
           input_files = SessionInbox.find_new_input_files(@session_dir)
           if input_files.empty?
+            next if run_wake_turn
             next if run_due_reminders
             return left(:idle_exit) if @idle_exit.due? && leave_idle
             return left(@exit_restart ? :restart : :exit_requested) if @exit_requested && leave_on_request
 
-            @waker.wait(@poll_interval)
+            @waker.wait(idle_wait)
             next
           end
 
@@ -216,6 +272,8 @@ module Samagotchi
         # Its stderr is /dev/null: the log is the only trace of why.
         Log.exception(:worker, "crashed", e)
         Session.mark_error(@session_id, reason: e.message, state_dir: @state_dir)
+        # A delegate's parent hears of it (best effort).
+        ChildRing.ring(@session, why: "crash", state_dir: @state_dir) if @session
         :crashed
       ensure
         # The anytime commands finish and the plugins' services stop (a
@@ -224,6 +282,9 @@ module Samagotchi
         # step-limit question stays in the file (a save here would write
         # over a stop's status): with no live worker the lists don't read
         # it as waiting, and the next worker drops it (drop_dead_question).
+        # The context poller first: a command it runs goes (its process
+        # group) before the Engine does.
+        @context_poller&.stop
         @engine&.shutdown
         @bridge&.stop
       end
@@ -333,6 +394,117 @@ module Samagotchi
       claimed.each { |file| FileUtils.rm_f(file) }
     end
 
+    # The attached context's notes (ContextAbsorber), between turns. Not
+    # into a session with no turn yet (+before_turn+: one is about to
+    # run): auto-attached context alone doesn't make a session worth
+    # keeping. Saved, then the subscriptions written (a crash between the
+    # two re-delivers; the note ids dedupe).
+    # +wake+: the session is idle with nothing queued, so an update whose
+    # source asked to wake may start a turn (#context_wake_for): its note
+    # goes in as the turn's first message.
+    # @return [Boolean] whether a wake turn ran
+    def absorb_context(before_turn: false, wake: false)
+      return false unless before_turn || conversation_started?
+      return false if stopped_on_disk?
+
+      batch = @context_absorber.pending
+      return false unless batch
+
+      waking = wake ? context_wake_for(batch) : nil
+      turn_id = SecureRandom.uuid if waking
+      batch.deliveries.each do |delivery|
+        next unless delivery.note
+
+        note = delivery == waking ? delivery.wake_note.merge(turn_start: true, turn_id: turn_id) : delivery.note
+        @engine.add_context_note(@session, note)
+      end
+      # Saved even when every note was there already: after a failed save
+      # they are in memory only.
+      return false if batch.notes.any? && !save_or_log(:context) { @session.save(state_dir: @state_dir) }
+
+      @context_absorber.commit(waking ? woken(batch, waking) : batch)
+      return false unless waking
+
+      run_context_wake_turn(waking.name, turn_id)
+      true
+    rescue SystemCallError, IOError => e
+      Log.exception(:worker, "context_failed", e)
+      false
+    end
+
+    # No input file or queued command waits: the loop would go idle.
+    def nothing_queued? = @command_queue.empty? && SessionInbox.find_new_input_files(@session_dir).empty?
+
+    # The update in +batch+ that may start a wake turn now: its source
+    # asked (wake: true), context.wake is on, the shared wake step's
+    # conditions hold (no continue offer, wakes not paused by a failed one,
+    # under session.max_wakes in a row with no human input, past the start
+    # grace) and the source hasn't woken the session in the last
+    # CONTEXT_WAKE_WINDOW. The others stay plain notes. Within the start
+    # grace a change is a note: it came while the session was away.
+    def context_wake_for(batch, now: Time.now)
+      candidates = batch.deliveries.select(&:wake_note)
+      return nil if candidates.empty? || !context_wakes_on?
+      return nil if @wakes_paused || @turn_flow.awaiting_continue? || wake_grace_left.positive?
+
+      if @wakes_in_a_row >= max_wakes
+        Log.info(:worker, "context_wake_held", reason: "max_wakes", names: candidates.map(&:name).join(","))
+        return nil
+      end
+      candidates.find { |delivery| !woke_lately?(delivery.subscription, now) }
+    end
+
+    def context_wakes_on? = Config.get("context.wake") != false
+
+    def woke_lately?(subscription, now)
+      at = subscription&.wakes_at && Time.iso8601(subscription.wakes_at)
+      at ? now - at < CONTEXT_WAKE_WINDOW : false
+    rescue ArgumentError
+      false
+    end
+
+    # +batch+ with +waking+'s subscription recording the wake (the 10-minute window).
+    def woken(batch, waking)
+      stamped = waking.with(subscription: waking.subscription.with(wakes_at: Time.now.iso8601))
+      batch.with(deliveries: batch.deliveries.map { |delivery| delivery == waking ? stamped : delivery })
+    end
+
+    # A turn nobody typed for a changed source (a context wake): a continue
+    # turn from context:<name> whose first message is the wake note already
+    # in the conversation (named by +turn_id+), on the same rules as a
+    # delegate report's wake turn: it counts toward session.max_wakes, and
+    # a failure goes back to before the turn (the note stays: it was saved
+    # before the checkpoint) and pauses wakes until a human's input.
+    def run_context_wake_turn(name, turn_id)
+      @wakes_in_a_row += 1
+      Log.info(:worker, "context_wake_turn", name: name, in_a_row: @wakes_in_a_row)
+      @turn_flow.before_prompt_turn
+      run_engine_turn(nil, continue: true, origin: { client_id: "#{Steer::CONTEXT_CLIENT_PREFIX}#{name}" },
+                           id: turn_id, max_iterations: IterationLimit.for) do |result, error|
+        if error
+          note = TurnNote.failed(error.respond_to?(:summary) ? error.summary : error.message)
+          @turn_flow.prompt_turn_failed(note: note)
+          @wakes_paused = true
+        else
+          @continue_offer.after_turn(result)
+        end
+      end
+    end
+
+    # Whether the session has had a turn: a user or assistant message.
+    def conversation_started?
+      Array(@session.messages).any? { |m| %w[user assistant model].include?((m[:role] || m["role"]).to_s) }
+    end
+
+    # The first prompt (spawn_session's): a delegate child's task, which is
+    # its parent's although no client sent it.
+    def run_initial_prompt(prompt)
+      @initial_turn = true
+      run_prompt(prompt, nil)
+    ensure
+      @initial_turn = false
+    end
+
     def run_input_file(input_file)
       claimed_file = SessionInbox.claim_input_file(input_file)
       return unless claimed_file
@@ -352,10 +524,11 @@ module Samagotchi
     #   its continue turn
     # @param images [Array<Hash>] the prompt's image refs ({file:, name:})
     def run_prompt(prompt, origin, no_interrupt: false, images: [])
+      # A first turn sees the context attached before it.
+      absorb_context(before_turn: true)
       user_input(origin&.dig(:client_id))
       @continue_offer.drop(origin)
       @turn_flow.before_prompt_turn
-      @merged_this_turn = []
       run_engine_turn(prompt, origin: origin, max_iterations: max_iterations(no_interrupt),
                               images: images) do |result, error|
         if error
@@ -387,6 +560,85 @@ module Samagotchi
       true
     end
 
+    # :due when an idle parent should run a turn for its delegate
+    # children's reports now (session.delegate_reports: wake): rings wait,
+    # no continue offer does (they merge into its turn), wakes aren't paused
+    # by a failed one, and the wake budget isn't spent; :budget when only
+    # the budget stops it; nil otherwise.
+    def wake_state
+      return nil unless @child_reports && ChildRing.mode == "wake"
+      return nil if @wakes_paused || @turn_flow&.awaiting_continue?
+      return nil unless @child_reports.waiting?
+
+      @wakes_in_a_row < max_wakes ? :due : :budget
+    end
+
+    # Run a turn nobody typed for the reports the rings bring (a wake turn):
+    # a continue turn (no prompt bubble) whose first boundary merges them,
+    # with origin child:<id8>. A failure goes back to the checkpoint, keeps
+    # the rings and pauses wakes until a human's input (a provider outage
+    # doesn't loop).
+    # @return [Boolean] whether a wake turn ran
+    def run_wake_turn
+      return false if wake_grace_left.positive?
+
+      state = wake_state
+      budget_notice if state == :budget
+      return false unless state == :due
+
+      reports, = take_child_reports
+      # The turn must not generate with nothing to say: the drain gets this
+      # exact list at its first boundary.
+      return false if reports.empty?
+
+      @wake_reports = reports
+      @wakes_in_a_row += 1
+      Log.info(:worker, "delegate_wake_turn", reports: reports.size, in_a_row: @wakes_in_a_row)
+      @turn_flow.before_prompt_turn
+      run_engine_turn(nil, continue: true, origin: reports.first.origin, max_iterations: IterationLimit.for) do |result, error|
+        if error
+          note = TurnNote.failed(error.respond_to?(:summary) ? error.summary : error.message)
+          @turn_flow.prompt_turn_failed(note: note)
+          @wakes_paused = true
+        else
+          @continue_offer.after_turn(result)
+        end
+      end
+      true
+    ensure
+      @wake_reports = nil
+    end
+
+    def wake_grace_left
+      WAKE_START_GRACE - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at)
+    end
+
+    # The idle loop's sleep: the fallback tick, or less while reports wait
+    # out the start grace.
+    def idle_wait
+      left = wake_grace_left
+      left.positive? && wake_state == :due ? [left, @poll_interval].min : @poll_interval
+    end
+
+    def max_wakes
+      value = Integer(Config.get(ChildRing::MAX_WAKES_KEY), exception: false)
+      value&.positive? ? value : ChildRing::MAX_WAKES_DEFAULT
+    rescue StandardError
+      ChildRing::MAX_WAKES_DEFAULT
+    end
+
+    # The wake budget is spent: the parent's UIs hear once that reports
+    # wait for the next message.
+    def budget_notice
+      return if @budget_noticed
+
+      @budget_noticed = true
+      count = SessionInbox.find_ring_files(@session_dir).map { |f| SessionInbox.read_ring(f)&.dig(:child_id) }.uniq.size
+      @engine.announce(type: :hook_notice, hook: "delegate", level: :info, between_turns: true,
+                       text: "#{count} delegate report#{"s" if count != 1} waiting; #{count == 1 ? "it joins" : "they join"} " \
+                             "your next message (#{max_wakes} turn#{"s" if max_wakes != 1} ran for reports in a row, #{ChildRing::MAX_WAKES_KEY})")
+    end
+
     def max_iterations(no_interrupt) = IterationLimit.for(no_interrupt: no_interrupt)
 
     # @return [Boolean] whether any command ran
@@ -496,6 +748,10 @@ module Samagotchi
     # @yieldparam result [Object, nil] Engine#run_turn's, nil on a failure
     # @yieldparam error [StandardError, nil]
     def run_engine_turn(prompt, **turn_args)
+      # Every kind of turn merges steering (a reminder turn too, which may be
+      # a fresh worker's first), so the list is this turn's from the start.
+      @merged_this_turn = []
+      @reporting_turn = reports_to_parent?(turn_args[:origin])
       begin
         @session.status = Session::STATUS_RUNNING
         @session.save(state_dir: @state_dir)
@@ -519,6 +775,51 @@ module Samagotchi
         SessionInbox.write_output(@session_dir, response)
       end
       save_or_log(:turn) { save_session }
+      settle_child_reports(error)
+      ring_parent_after_turn
+    end
+
+    # The delegate reports this turn took: a kept turn moves the cursors on
+    # and deletes their rings; a failed one (rolled back) leaves the rings
+    # for the next turn.
+    def settle_child_reports(error)
+      error ? @child_reports.release : @child_reports.commit
+    end
+
+    # A delegate child's turn that was its parent's (#reports_to_parent?)
+    # rings the parent, after the save: the parent reads a settled child.
+    # A question it rang about that still waits makes the next turn ring
+    # too, whoever starts it (the user answering Continue on the web).
+    def ring_parent_after_turn
+      ChildRing.ring(@session, why: "turn_end", state_dir: @state_dir) if @reporting_turn
+      @owes_parent = @asked_parent && !@session.pending_question.nil?
+      @asked_parent = false
+      @reporting_turn = false
+    end
+
+    # Whether the turn starting now is a delegate child's parent's: its
+    # task (the initial prompt), a follow-up, a continue the parent
+    # answered, a reminder, anything but a human typing into the child
+    # (ArchiveStore.user_input?), and any turn after a question the parent
+    # was rung about.
+    def reports_to_parent?(origin)
+      return false unless @session.delegate?
+
+      @initial_turn || @owes_parent || !ArchiveStore.user_input?(origin&.dig(:client_id))
+    end
+
+    # The Engine published a question (after the question desk saved it).
+    # In a turn that reports to the parent, the model's own question and
+    # the step-limit continue ring it; approvals and hooks' questions are
+    # the user's, on this session's card.
+    def ring_question(event)
+      return unless @reporting_turn
+
+      kind = event.dig(:pending_question, :kind).to_s
+      return unless ["", ContinueOffer::KIND].include?(kind)
+
+      ChildRing.ring(@session, why: "question", state_dir: @state_dir)
+      @asked_parent = true
     end
 
     # A save between turns (the turn's own, a command's, the notes', the
@@ -588,14 +889,42 @@ module Samagotchi
           end
         end
         merged.each { |_prompt, origin| user_input(origin&.dig(:client_id)) }
-        unless merged.empty?
-          @engine.announce(type: :input_merged, count: merged.size, origins: merged.filter_map(&:last))
+        # Delegate children's reports: never handed back on a failure
+        # (their rings stay for the next turn), so not in @merged_this_turn.
+        reports, mark = take_child_reports
+        unless merged.empty? && reports.empty?
+          @engine.announce(type: :input_merged, count: merged.size + reports.size,
+                           origins: merged.filter_map(&:last) + reports.map(&:origin))
           @merged_this_turn.concat(merged)
         end
         # Each line keeps its sender (Steer.source_for_client): a chi send or
         # a delegating parent's line is saved and shown to the model as theirs.
-        merged.map { |prompt, origin| Steer::Line.new(text: prompt, source: Steer.source_for_client(origin&.dig(:client_id))) }
+        lines = merged.map { |prompt, origin| Steer::Line.new(text: prompt, source: Steer.source_for_client(origin&.dig(:client_id))) } +
+                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?
+        lines
+      end
+    end
+
+    # The reports for rings that came in since the turn last looked. A
+    # failure to read them must not take the turn's steering with it.
+    # A wake turn's first call gets the reports it was started for (their
+    # message is the turn's start: turn_start, turn_id, so a reload shows
+    # the turn as its own).
+    # @return [Array(Array<ChildReports::Report>, Hash|nil)] the reports
+    #   and the mark of their message
+    def take_child_reports
+      if @wake_reports
+        reports = @wake_reports
+        @wake_reports = nil
+        return [reports, { turn_start: true, turn_id: @turn_id }.compact]
       end
+
+      [@child_reports.take, nil]
+    rescue StandardError => e
+      Log.warn(:worker, "delegate_reports_failed", error: e.class.name, msg: e.message)
+      [[], nil]
     end
 
     # Check again with the event log held, which the Bridge holds while it
@@ -696,8 +1025,14 @@ module Samagotchi
 
     # A human's input (ArchiveStore.user_input?) un-archives the session;
     # a delegate's, a plugin's or a reminder's doesn't.
+    # It also resets the delegate-report wakes (budget and pause).
     def user_input(client_id)
-      ArchiveStore.user_input(@session_id, state_dir: @state_dir) if ArchiveStore.user_input?(client_id)
+      return unless ArchiveStore.user_input?(client_id)
+
+      ArchiveStore.user_input(@session_id, state_dir: @state_dir)
+      @wakes_in_a_row = 0
+      @wakes_paused = false
+      @budget_noticed = false
     end
 
     def stopped_on_disk?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -125,6 +125,7 @@ files:
 - docs/architecture.md
 - docs/cli.md
 - docs/configuration.md
+- docs/context.md
 - docs/desktop.md
 - docs/guardrails.md
 - docs/hooks.md
@@ -170,6 +171,9 @@ files:
 - lib/samagotchi/bundles/check-in/plugin.rb
 - lib/samagotchi/bundles/core/manifest.yml
 - lib/samagotchi/bundles/dev/manifest.yml
+- lib/samagotchi/bundles/github-pr/manifest.yml
+- lib/samagotchi/bundles/github-pr/plugin.rb
+- lib/samagotchi/bundles/github-pr/scripts/pr_context.rb
 - lib/samagotchi/bundles/guardrails/guardrails.md
 - lib/samagotchi/bundles/guardrails/guardrails/rules.yml
 - lib/samagotchi/bundles/guardrails/guardrails/small-models.yml
@@ -193,6 +197,7 @@ files:
 - lib/samagotchi/bundles/system/memory_guide.md
 - lib/samagotchi/bundles/system/self_map.md
 - lib/samagotchi/cancellation_controller.rb
+- lib/samagotchi/child_reports.rb
 - lib/samagotchi/cli/command.rb
 - lib/samagotchi/cli/exit.rb
 - lib/samagotchi/cli/flags.rb
@@ -202,8 +207,14 @@ files:
 - lib/samagotchi/commands/registry.rb
 - lib/samagotchi/config.rb
 - lib/samagotchi/config_text_edit.rb
+- lib/samagotchi/context_absorber.rb
+- lib/samagotchi/context_command.rb
+- lib/samagotchi/context_fetch.rb
 - lib/samagotchi/context_note.rb
+- lib/samagotchi/context_poller.rb
+- lib/samagotchi/context_providers.rb
 - lib/samagotchi/context_quote.rb
+- lib/samagotchi/context_sources.rb
 - lib/samagotchi/context_status.rb
 - lib/samagotchi/context_usage.rb
 - lib/samagotchi/context_window.rb
@@ -314,6 +325,7 @@ files:
 - lib/samagotchi/paths.rb
 - lib/samagotchi/pending_input_queue.rb
 - lib/samagotchi/plugin/api.rb
+- lib/samagotchi/plugin/attached_context.rb
 - lib/samagotchi/plugin/context.rb
 - lib/samagotchi/plugin/loader.rb
 - lib/samagotchi/plugin/service.rb
@@ -393,7 +405,9 @@ files:
 - lib/samagotchi/tools/builtin_calls.rb
 - lib/samagotchi/tools/builtins.rb
 - lib/samagotchi/tools/cancel_reminder.rb
+- lib/samagotchi/tools/context_read.rb
 - lib/samagotchi/tools/delegate.rb
+- lib/samagotchi/tools/delegate_cursor.rb
 - lib/samagotchi/tools/delegate_relay.rb
 - lib/samagotchi/tools/delegate_result.rb
 - lib/samagotchi/tools/delegate_wait.rb
@@ -446,6 +460,7 @@ files:
 - lib/samagotchi/web/public/command_list.js
 - lib/samagotchi/web/public/command_view.js
 - lib/samagotchi/web/public/composer_size.js
+- lib/samagotchi/web/public/context_chips.js
 - lib/samagotchi/web/public/copy.js
 - lib/samagotchi/web/public/ctx.js
 - lib/samagotchi/web/public/data.js