samagotchi 0.6.0 → 0.8.0

data/lib/samagotchi/engine.rb

@@ -71,10 +71,9 @@ module Samagotchi
     # Used by specs and inspection.
     def self.system_prompt_for(profile)
       profile = ModelProfile.normalize(profile) unless profile.is_a?(ModelProfile)
-      new(mode: :assist, profile: profile, plugins: false).assist_system_prompt
+      new(profile: profile, plugins: false).assist_system_prompt
     end
 
-    # @param mode               [Symbol] :assist (harness is single-mode; memory-reliant; kwarg kept for compat, ignored)
     # @param client             [Client, nil] defaults to Client.new
     # @param profile            [ModelProfile, Symbol, String, nil]
     # @param session_id         [String, nil] resume an existing session
@@ -89,9 +88,8 @@ module Samagotchi
     # @param plugins            [Boolean] false: load no bundle plugins (a throwaway Engine for a prompt)
     # @param scratch            [Boolean] a `chi scratch` session: memory writes are refused, and there is no
     #   delegate (a child would outlive it) nor plugin fork
-    def initialize(mode: :assist, client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, model_name: nil, memories: [], muted_memories: [], kernel: nil, recap: nil, reminders: nil,
+    def initialize(client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, model_name: nil, memories: [], muted_memories: [], kernel: nil, recap: nil, reminders: nil,
                    plugins: true, scratch: false)
-      @mode = mode.to_sym
       @scratch = scratch
       @chat_backend = nil
       @chat_backend_mutex = Mutex.new
@@ -518,7 +516,7 @@ module Samagotchi
     # The array is replaced, not mutated, and the append and the event
     # happen under the event lock, so a joining UI sees both or neither.
     # The caller saves the session.
-    # @param note [Hash] SessionManager.read_note's shape
+    # @param note [Hash] SessionInbox.read_note's shape
     # @return [Hash, nil] the message, or nil when the conversation already
     #   holds this note (a note file re-read after a crash)
     def add_context_note(session, note)
@@ -1278,7 +1276,7 @@ module Samagotchi
       return false unless ctrl && !ctrl.cancelled?
 
       hook_notify("stopped the turn: #{reason}", :warn, hook)
-      ctrl.cancel!(:hook)
+      ctrl.cancel!(:hook, { by: hook_source(hook), reason: reason.to_s })
     end
     private :hook_stop_turn
 
@@ -1645,6 +1643,7 @@ module Samagotchi
             conversation << note if conversation
           elsif canceled && conversation
             conversation << TurnNote.cancelled(result.cancellation_reason, seconds: turn_seconds.call,
+                                                                          stopped_by: effective_controller.detail,
                                                                           shown: TurnNote.interrupted_tail?(conversation),
                                                                           running_tasks: Tools::TaskRuntime.running_created_in(conversation))
             replace_session_messages(session, conversation)
@@ -1959,7 +1958,7 @@ module Samagotchi
     def load_hooks_from_bundles
       require_relative "memory_bundle/provenance"
       settings = bundle_settings
-      MemoryBundle::Provenance.each_installed_holding_hooks do |bundle_name, data|
+      MemoryBundle::Provenance.each_installed(holding: :hooks) do |bundle_name, data|
         if data[:error]
           Log.warn(:hooks, "bundle_manifest_invalid", echo: "[samagotchi:hooks] bundle '#{bundle_name}': #{data[:error]}; its hooks are not loaded",
                                                       bundle: bundle_name)

data/lib/samagotchi/guardrail_wiring.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "digest"
 require "yaml"
 
 require_relative "config"
@@ -117,7 +116,7 @@ module Samagotchi
     def bundle_rules
       require_relative "memory_bundle/provenance"
       rules = []
-      MemoryBundle::Provenance.each_installed_with_guardrails do |bundle_name, data|
+      MemoryBundle::Provenance.each_installed(holding: :guardrails) do |bundle_name, data|
         if data[:error]
           Log.warn(:guardrails, "bundle_rules_invalid", echo: "[samagotchi:guardrails] bundle #{bundle_name}: #{data[:error]}", bundle: bundle_name)
           @failures.add("rules (bundle #{bundle_name})", data[:error], required: true, group: :rules)
@@ -130,9 +129,7 @@ module Samagotchi
           begin
             raise Guardrails::Rules::ParseError, "the file is missing" unless File.file?(path)
 
-            expected = (meta.is_a?(Hash) ? meta[:sha256] : nil).to_s.sub(/\Asha256:/, "")
-            actual = Digest::SHA256.hexdigest(File.binread(path))
-            if expected != actual
+            unless MemoryBundle::Provenance.sha_matches?(path, meta.is_a?(Hash) ? meta[:sha256] : nil)
               raise Guardrails::Rules::ParseError, "its sha256 differs from the installed one (edited after install? reinstall the bundle)"
             end
 

data/lib/samagotchi/guardrails/approvals.rb

@@ -3,6 +3,7 @@
 require "json"
 require "fileutils"
 require "time"
+require_relative "../atomic_file"
 require_relative "../log"
 require_relative "approval"
 
@@ -163,13 +164,7 @@ module Samagotchi
         with_lock do
           list = read(locked: true)
           yield list
-          tmp = "#{@path}.#{Process.pid}.#{Thread.current.object_id}.tmp"
-          begin
-            File.write(tmp, JSON.pretty_generate(list))
-            File.rename(tmp, @path)
-          ensure
-            FileUtils.rm_f(tmp)
-          end
+          AtomicFile.write(@path, JSON.pretty_generate(list))
         end
       end
     end

data/lib/samagotchi/hooks/bundle_loader.rb

@@ -3,6 +3,7 @@
 require_relative "registry"
 require "digest"
 require_relative "../log"
+require_relative "../memory_bundle/provenance"
 
 module Samagotchi
   # Namespace that wraps hook plugin classes per-bundle. Each bundle's hooks are
@@ -79,12 +80,14 @@ module Samagotchi
 
             begin
               plugin = instantiate(bundle_name, basename, file, settings: settings)
+              log_failure = Hooks.failure_log_gate(event_sym)
 
               registry.register_bundle(bundle_name, event_sym, hook_name: basename, priority: priority) do |event|
                 begin
                   plugin.call(event)
                 rescue Exception => e
-                  handle_error(bundle_name, basename, on_error, fail_closed, event, e)
+                  # A veto always applies; only the log line is throttled.
+                  handle_error(bundle_name, basename, on_error, fail_closed, event, e) if fail_closed || log_failure.call
                 end
               end
               loaded += 1
@@ -99,10 +102,10 @@ module Samagotchi
         # Why the file doesn't match the sha256 recorded at install, or nil.
         # With none recorded, only a required hook counts as a mismatch.
         def sha_mismatch(file, recorded, required:)
-          expected = recorded.to_s.sub(/\Asha256:/, "")
+          expected = MemoryBundle::Provenance.recorded_sha(recorded)
           return (required ? "no sha256 recorded for it (reinstall the bundle)" : nil) if expected.empty?
 
-          actual = Digest::SHA256.hexdigest(File.binread(file))
+          actual = MemoryBundle::Provenance.file_sha(file)
           return nil if actual == expected
 
           "its sha256 #{actual[0, 12]}… differs from the installed #{expected[0, 12]}… (edited after install? reinstall the bundle)"

data/lib/samagotchi/hooks/loader.rb

@@ -60,6 +60,7 @@ module Samagotchi
           definitions.each do |defn|
             begin
               plugin = load_plugin(hooks_dir, defn[:path], settings: defn[:settings])
+              log_failure = Hooks.failure_log_gate(defn[:event_type])
               # Persistent: config hooks must fire on every turn, not be wiped
               # by Engine#run_turn's per-turn clear_hooks after turn 1.
               registry.register_persistent(defn[:event_type].to_sym, label: "#{defn[:path]} (config)") do |event|
@@ -69,7 +70,7 @@ module Samagotchi
                   if defn[:required] && defn[:event_type] == "before_tool_call"
                     deny_for_raise(event, defn[:path], e)
                   else
-                    handle_error(defn[:on_error] || "skip", defn[:path], e)
+                    handle_error(defn[:on_error] || "skip", defn[:path], e) if log_failure.call
                   end
                 end
               end

data/lib/samagotchi/hooks/registry.rb

@@ -15,6 +15,27 @@ module Samagotchi
       takes_settings ? klass.new(settings.is_a?(Hash) ? settings : {}) : klass.new
     end
 
+    # A stream hook (:generation_progress) fires ~once a second: a broken
+    # one logs its failure once a minute, not on every fire.
+    FAILED_STREAM_HOOK_LOG_SECONDS = 60
+
+    # One hook's failure-log gate: called on each failure, it says whether
+    # to log this one (a :generation_progress hook's at most once a
+    # minute, any other hook's every time).
+    # @param event [Symbol, String] the hook's event
+    # @return [Proc] -> Boolean
+    def self.failure_log_gate(event)
+      quiet_for = event.to_s == "generation_progress" ? FAILED_STREAM_HOOK_LOG_SECONDS : 0
+      logged_at = nil
+      lambda do
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        next false if logged_at && now - logged_at < quiet_for
+
+        logged_at = now
+        true
+      end
+    end
+
     # What a hook can do beyond reading its event: the Engine's
     # callables, each given the hook's label. +notify+ takes
     # (text:, level:, hook:) and shows one line to the user; +ask_user+

data/lib/samagotchi/image_store.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "open3"
 require "securerandom"
 require "tmpdir"
+require_relative "atomic_file"
 require_relative "config"
 
 module Samagotchi
@@ -384,9 +385,7 @@ module Samagotchi
       path = File.join(session_dir.to_s, file)
       unless File.file?(path)
         FileUtils.mkdir_p(File.dirname(path))
-        tmp = "#{path}.#{SecureRandom.hex(4)}.tmp"
-        File.binwrite(tmp, bytes)
-        File.rename(tmp, path)
+        AtomicFile.write(path, bytes)
       end
       { file: file, mime: MIME.fetch(info.format), width: info.width, height: info.height,
         bytes: bytes.bytesize, name: name, source: source.to_s }

data/lib/samagotchi/kernel_loop.rb

@@ -3,7 +3,7 @@
 require_relative "model_profile"
 require_relative "tool_call_parser"
 require_relative "config"
-require_relative "context_usage"
+require_relative "context_status"
 require_relative "context_window"
 require_relative "prompt"
 require_relative "prompt_literal_guard"
@@ -37,20 +37,6 @@ module Samagotchi
   #   - Qwen 3.6: <tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>
   class KernelLoop
     Result = Struct.new(:output, :conversation, :exhausted, :pending_tool_calls, :tool_activity, :canceled, :cancellation_reason, :context_status, keyword_init: true) do
-      def to_s
-        output.to_s
-      end
-
-      alias to_str to_s
-
-      def ==(other)
-        if other.is_a?(self.class)
-          super
-        else
-          to_s == other
-        end
-      end
-
       def exhausted?
         exhausted
       end
@@ -66,25 +52,6 @@ module Samagotchi
       def canceled?
         canceled
       end
-
-      # Struct/Enumerable defines include? with collection semantics, but the
-      # historical KernelLoop#run contract returned a String. Keep include?
-      # aligned with String#include? for backward compatibility.
-      def include?(needle)
-        to_s.include?(needle)
-      end
-
-      # Keep compatibility with existing callers/specs that treat run() as a
-      # plain string (e.g., include?, match, start_with?).
-      def method_missing(name, *args, &block)
-        return to_s.public_send(name, *args, &block) if to_s.respond_to?(name)
-
-        super
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        to_s.respond_to?(name, include_private) || super
-      end
     end
 
     # The built-in tool classes (Tools::Builtins registers them).
@@ -105,16 +72,6 @@ module Samagotchi
       def ask_user_question(call) = @kernel.__send__(:handle_ask_user_question, call)
     end
 
-    CONTEXT_STATUS_PREFIX = "CONTEXT_STATUS"
-    # The model's own line about its context (a tail system message, kind
-    # CONTEXT_LINE_KIND), left once per rise into a bucket whose guidance
-    # asks for a change: from the second threshold (40% by default) up.
-    CONTEXT_LINE_PREFIX = "[CONTEXT: "
-    CONTEXT_LINE_KIND = "context"
-    CONTEXT_GUIDANCE_FROM_RANK = 2
-
-    DEFAULT_CONTEXT_CHARS_PER_TOKEN = 4.0
-    DEFAULT_CONTEXT_THRESHOLDS = [20, 40, 60, 80].freeze
     DEFAULT_MAX_TOOL_OUTPUT_CHARS = 10_000
     QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_LIMIT = 2
     QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_PROMPT = "Continue the previous assistant message by finishing the open <tool_call> XML block. Output only the remaining XML needed to complete the tool call."
@@ -204,7 +161,7 @@ module Samagotchi
       @current_model_name = resolved_model_name
 
       conversation = prepare_conversation(messages)
-      context_state = initial_context_status_state(conversation)
+      context = ContextStatus.new(conversation: conversation)
       exhausted = false
       pending_tool_calls = false
       tool_activity = []
@@ -213,7 +170,6 @@ module Samagotchi
       empty_retries = 0
       empty_retry_limit = EmptyAnswerRetry.limit
       @retry_generation = false
-      context_status = nil
       stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
       # Qwen with thinking off: an empty thought after the cue, so the model
       # answers at once. Kept in the turn's model messages, so each tool-loop
@@ -228,9 +184,9 @@ module Samagotchi
         prompt, images = Prompt.format_with_images(conversation, profile: @profile, vision: @vision, prefill: prefill)
         image_tokens = images.empty? ? 0 : ImagePlan.estimated_tokens(conversation)
         context_window = ContextWindow.resolve(client: @client, model: resolved_model_name)
-        context_status = emit_context_status_event(on_stream_event, prompt, iteration_index: iteration_index, state: context_state, window: context_window,
-                                                                            image_tokens: image_tokens) || context_status
-        if (line = context_state.delete(:guidance))
+        emit_context_status_event(on_stream_event, context, prompt, iteration_index: iteration_index, window: context_window,
+                                                                    image_tokens: image_tokens)
+        if (line = context.take_guidance)
           # The model's own copy, on the tail (the prompt cache keeps its
           # prefix), then the prompt again with it.
           conversation << line
@@ -246,8 +202,8 @@ module Samagotchi
           profile_source: @profile_source
         )
         served_model = nil
-        # This generation's own server counts (the run-long
-        # context_state[:server_usage] can hold an earlier one's).
+        # This generation's own server counts (the run-long ones in
+        # `context` can be an earlier one's).
         generation_usage = nil
         # The thinking this generation streamed, for the log (a stuck
         # thinking generation shows as thinking_chars=N content_length=…).
@@ -266,7 +222,7 @@ module Samagotchi
             cancel_controller: cancel_controller,
             model_name: resolved_model_name,
             on_chunk: lambda { |chunk|
-              generation_usage = capture_server_usage(chunk[:payload], context_state) || generation_usage
+              generation_usage = context.capture(chunk[:payload]) || generation_usage
               # llama.cpp names the loaded model in the stream's last payload.
               named = chunk[:payload]["model"] if chunk[:payload].is_a?(Hash)
               served_model = named if named.is_a?(String) && !named.strip.empty?
@@ -333,14 +289,11 @@ module Samagotchi
           # No retry left: the turn ends as cancelled (hook), with nothing
           # salvaged and without the spent nudge.
           drop_last_empty_retry!(conversation)
-          cancel_controller.cancel!(:hook)
+          cancel_controller.cancel!(:hook, cut)
           emit_stream_event(on_stream_event, type: :generation_cancelled, iteration: iteration_index + 1, reason: :hook)
           return cancelled_result(conversation, tool_activity: tool_activity, reason: :hook, partial_assistant_text: "")
         end
-        # What the server's prompt count covers, so the next estimate adds
-        # only what the turn appended since (answer, tool results).
-        context_state[:counted] = { chars: prompt.length, image_tokens: image_tokens } if generation_usage
-        refresh_context_display(context_state, generation_usage, context_window)
+        context.generation_done(generation_usage, prompt_chars: prompt.length, image_tokens: image_tokens, window: context_window)
         emit_stream_event(
           on_stream_event,
           type: :generation_completed,
@@ -465,7 +418,7 @@ module Samagotchi
         tool_activity: tool_activity,
         canceled: false,
         cancellation_reason: nil,
-        context_status: context_state[:display] || context_status
+        context_status: context.display
       )
     rescue StandardError => e
       LLM::FailedTurn.attach(e, conversation && duplicate_conversation(conversation))
@@ -667,227 +620,16 @@ module Samagotchi
       Log.debug(:model, event, payload: payload, model: @current_model_name, **fields)
     end
 
-    # Estimate context usage for this iteration's prompt and, when the emit
-    # gate fires, surface it to stream consumers as a :context_status event.
-    # A rise into a bucket that asks the model for a change also leaves a
-    # short line for it (state[:guidance], see context_guidance_message):
-    # not the telemetry, which the model no longer receives (it used to be injected as a
-    # synthetic system message); the returned {est_pct:, bucket:} hash feeds
-    # the Result's context_status for UI status lines (nil when not emitted).
-    def emit_context_status_event(on_stream_event, prompt, iteration_index:, state:, window: nil, image_tokens: 0)
-      return nil unless context_status_enabled?
-
-      usage = estimate_context_usage(prompt, server_usage: state[:server_usage], window: window, image_tokens: image_tokens,
-                                             counted: state[:counted])
-      bucket = context_status_bucket(usage[:estimated_pct])
-      # The status line's value, every iteration; the gate below decides
-      # only the event and the model's guidance line.
-      state[:display] = { est_pct: usage[:estimated_pct], bucket: bucket }
-      emit_status = should_emit_context_status?(state: state, bucket: bucket, iteration_index: iteration_index)
-      previous_bucket = state[:last_bucket]
-      state[:last_bucket] = bucket
-      return nil unless emit_status
-
-      state[:guidance] = context_guidance_message(usage: usage, bucket: bucket) if guidance_due?(previous_bucket, bucket)
-
-      status_message = context_status_message(usage: usage, bucket: bucket, source: usage[:source])
-      emit_stream_event(
-        on_stream_event,
-        type: :context_status,
-        iteration: iteration_index + 1,
-        status: status_message,
-        usage: usage,
-        bucket: bucket,
-        source: usage[:source]
-      )
-      dump_log("context_status", status_message, iteration: iteration_index + 1, bucket: bucket)
-      { est_pct: usage[:estimated_pct], bucket: bucket }
-    end
-
-    # @return [Hash, nil] the payload's normalized counts, when it has any
-    def capture_server_usage(payload, state)
-      normalized = ContextUsage.normalize(payload)
-      state[:server_usage] = normalized if normalized
-      normalized
-    end
-
-    # After a generation: the status line's value from what the server
-    # reported for it (prompt + answer), so a turn's value counts its last
-    # answer. Without counts the pre-generation estimate stays.
-    def refresh_context_display(state, usage, window)
-      return unless usage
-
-      display = context_display(used_tokens: usage[:total_tokens],
-                                window_tokens: usage[:context_window_tokens] || window&.tokens)
-      state[:display] = display if display
-    end
-
-    def initial_context_status_state(conversation)
-      { last_bucket: extract_last_context_status_bucket(conversation) }
-    end
-
-    # The bucket of the last status line the conversation holds: the model's
-    # own line, or a legacy session's injected telemetry.
-    def extract_last_context_status_bucket(conversation)
-      message = conversation.reverse.find do |entry|
-        content = entry[:content].to_s
-        entry[:role] == "system" && (content.start_with?(CONTEXT_STATUS_PREFIX) || content.start_with?(CONTEXT_LINE_PREFIX))
-      end
-      return nil unless message
-
-      match = message[:content].match(/\bbucket=([a-z0-9_]+)/)
-      match && match[1]
-    end
-
-    def context_status_enabled?
-      Samagotchi::Config.get("context.status") != false
-    end
-
-    # `window` is this iteration's ContextWindow::Resolved (resolved here when
-    # not given). A window the stream payload reports itself still wins.
-    # +image_tokens+: the images' estimate (their base64 is not in +prompt+).
-    # +counted+: the prompt the server's prompt_tokens counted ({chars:,
-    # image_tokens:}); what +prompt+ has on top of it (the answer, tool
-    # results since) is added as an estimate, so the value doesn't read low
-    # during a long tool loop. A prompt shorter than that one (trimmed) or
-    # none known: the server's count alone.
-    def estimate_context_usage(prompt, server_usage: nil, window: nil, image_tokens: 0, counted: nil)
-      window ||= ContextWindow.resolve(client: @client, model: @current_model_name)
-      window_source = window.source
-      if server_usage && server_usage[:context_window_tokens]
-        window_source = :server
-      end
-
-      if server_usage && server_usage[:prompt_tokens]
-        window_tokens = server_usage[:context_window_tokens] || window.tokens
-        estimated_used_tokens = server_usage[:prompt_tokens] + appended_tokens(prompt, image_tokens, counted)
-        estimated_remaining_tokens = [window_tokens - estimated_used_tokens, 0].max
-        estimated_pct = (estimated_used_tokens.to_f / window_tokens) * 100.0
-
-        return {
-          window_tokens: window_tokens,
-          window_source: window_source,
-          estimated_used_tokens: estimated_used_tokens,
-          estimated_remaining_tokens: estimated_remaining_tokens,
-          estimated_pct: estimated_pct,
-          source: "server"
-        }
-      end
-
-      window_tokens = window.tokens
-      estimated_used_tokens = (prompt.length / context_chars_per_token).ceil + image_tokens
-      estimated_remaining_tokens = [window_tokens - estimated_used_tokens, 0].max
-      estimated_pct = (estimated_used_tokens.to_f / window_tokens) * 100.0
-
-      {
-        window_tokens: window_tokens,
-        window_source: window_source,
-        estimated_used_tokens: estimated_used_tokens,
-        estimated_remaining_tokens: estimated_remaining_tokens,
-        estimated_pct: estimated_pct,
-        source: "estimate"
-      }
-    end
-
-    # The estimate for what +prompt+ added since the +counted+ one.
-    def appended_tokens(prompt, image_tokens, counted)
-      return 0 unless counted
-
-      chars = prompt.length - counted[:chars]
-      return 0 unless chars.positive?
-
-      (chars / context_chars_per_token).ceil + [image_tokens - counted[:image_tokens].to_i, 0].max
-    end
-
-    def context_chars_per_token
-      value = Samagotchi::Config.get("context.chars_per_token").to_f
-      value.positive? ? value : DEFAULT_CONTEXT_CHARS_PER_TOKEN
-    end
-
-    def context_status_thresholds
-      raw = Samagotchi::Config.get("context.status_thresholds").to_s
-      parsed = raw.split(",").map { |value| value.strip.to_i }.select { |value| value.between?(1, 99) }.uniq.sort
-      parsed.empty? ? DEFAULT_CONTEXT_THRESHOLDS : parsed
-    end
-
-    def context_status_cadence
-      [Samagotchi::Config.get("context.status_cadence").to_i, 0].max
-    end
-
-    # 0 for the bucket under the first threshold, then one per threshold.
-    def bucket_rank(bucket)
-      return 0 if bucket.nil? || bucket.to_s.start_with?("under")
-
-      (context_status_thresholds.index(bucket.to_s.delete_suffix("plus").to_i) || -1) + 1
-    end
-
-    # A rise (never a fall or a cadence tick) into a bucket whose guidance
-    # asks for a change. With no previous bucket (a first turn, a resumed
-    # session with no line yet), the first bucket counts as a rise from 0.
-    def guidance_due?(previous, bucket)
-      rank = bucket_rank(bucket)
-      rank >= CONTEXT_GUIDANCE_FROM_RANK && rank > bucket_rank(previous)
-    end
-
-    def context_guidance_message(usage:, bucket:)
-      how = usage[:source].to_s == "server" ? "as the server reports" : "estimated"
-      { role: "system", kind: CONTEXT_LINE_KIND,
-        content: "#{CONTEXT_LINE_PREFIX}about #{usage[:estimated_pct].to_f.round}% of the context window is in use " \
-                 "(#{how}; bucket=#{bucket}). #{context_status_guidance(bucket)}]" }
-    end
-
-    def context_status_bucket(estimated_pct)
-      thresholds = context_status_thresholds
-      bucket = "under#{thresholds.first}"
-      thresholds.each do |threshold|
-        bucket = "#{threshold}plus" if estimated_pct >= threshold
-      end
-      bucket
-    end
-
-    def should_emit_context_status?(state:, bucket:, iteration_index:)
-      last_bucket = state[:last_bucket]
-      below_threshold_bucket = "under#{context_status_thresholds.first}"
-      bucket_changed = if last_bucket.nil?
-                         bucket != below_threshold_bucket
-                       else
-                         bucket != last_bucket
-                       end
-
-      cadence = context_status_cadence
-      cadence_due = cadence.positive? && ((iteration_index + 1) % cadence).zero?
-      bucket_changed || cadence_due
-    end
+    # Estimate context usage for this iteration's prompt (ContextStatus#observe)
+    # and, when the emit gate fires, surface it to stream consumers as a
+    # :context_status event. The telemetry is not for the model (it used to
+    # be injected as a synthetic system message).
+    def emit_context_status_event(on_stream_event, context, prompt, iteration_index:, window:, image_tokens: 0)
+      event = context.observe(prompt, iteration_index: iteration_index, window: window, image_tokens: image_tokens)
+      return unless event
 
-    def context_status_message(usage:, bucket:, source:)
-      format(
-        "%<prefix>s window_tokens=%<window>d window_src=%<window_src>s est_used_tokens=%<used>d est_remaining_tokens=%<remaining>d est_pct=%<pct>.1f bucket=%<bucket>s thresholds=%<thresholds>s src=%<src>s guidance=%<guidance>s",
-        prefix: CONTEXT_STATUS_PREFIX,
-        window: usage[:window_tokens],
-        window_src: usage[:window_source] || "default",
-        used: usage[:estimated_used_tokens],
-        remaining: usage[:estimated_remaining_tokens],
-        pct: usage[:estimated_pct],
-        bucket: bucket,
-        thresholds: context_status_thresholds.join(","),
-        src: source,
-        guidance: context_status_guidance(bucket)
-      )
-    end
-
-    def context_status_guidance(bucket)
-      case bucket
-      when "under20", "20plus"
-        "context healthy — proceed normally"
-      when "40plus"
-        "context moderate — prefer targeted and range reads over full-file dumps"
-      when "60plus"
-        "context elevated — be concise, prefer range reads, avoid re-reading large files"
-      when "80plus"
-        "context critical — summarize aggressively, avoid large outputs, delegate broad work to subagents"
-      else
-        "context healthy — proceed normally"
-      end
+      emit_stream_event(on_stream_event, type: :context_status, iteration: iteration_index + 1, **event)
+      dump_log("context_status", event[:status], iteration: iteration_index + 1, bucket: event[:bucket])
     end
 
     public
@@ -904,11 +646,7 @@ module Samagotchi
     # of +window_tokens+; nil without both, or with context.status off. The
     # chat loop builds its value with it too.
     def context_display(used_tokens:, window_tokens:)
-      return nil unless context_status_enabled?
-      return nil unless ContextWindow.positive_integer?(used_tokens) && ContextWindow.positive_integer?(window_tokens)
-
-      pct = (used_tokens.to_f / window_tokens) * 100.0
-      { est_pct: pct, bucket: context_status_bucket(pct) }
+      ContextStatus.new.display_for(used_tokens: used_tokens, window_tokens: window_tokens)
     end
 
     # Per-profile parse strategy. Rebuilt when the active profile changes

data/lib/samagotchi/live_versions.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
 require "socket"
 require_relative "session"
 require_relative "version"
+require_relative "worker_sidecar"
+require_relative "web/info_probe"
 
 module Samagotchi
   # Which chi versions the running processes run, for `chi update`: session
@@ -22,13 +22,12 @@ module Samagotchi
 
     # @return [Array<Worker>] the workers whose Bridge answers, by session id
     def workers(state_dir: Session.default_state_dir)
-      Dir[File.join(state_dir, "*", "bridge.json")].sort.filter_map do |sidecar|
-        data = JSON.parse(File.read(sidecar))
-        next unless data.is_a?(Hash) && listening?(data["port"].to_i)
+      Dir[File.join(state_dir, "*", WorkerSidecar::FILE)].sort.filter_map do |path|
+        session_dir = File.dirname(path)
+        sidecar = WorkerSidecar.read(session_dir)
+        next unless sidecar && listening?(sidecar.port)
 
-        Worker.new(session_id: File.basename(File.dirname(sidecar)), version: data["version"])
-      rescue JSON::ParserError, SystemCallError
-        nil
+        Worker.new(session_id: File.basename(session_dir), version: sidecar.version)
       end
     end
 
@@ -46,11 +45,8 @@ module Samagotchi
     # The /api/info of a chi web on host:port, or nil when nothing (or not
     # chi web) answers.
     def web_info(host, port, timeout: WEB_TIMEOUT)
-      response = Net::HTTP.start(host, port, open_timeout: timeout, read_timeout: timeout) { |http| http.get("/api/info") }
-      info = response.code.to_i == 200 ? JSON.parse(response.body.to_s) : nil
-      info.is_a?(Hash) && info["app"] == "chi-web" ? info : nil
-    rescue StandardError
-      nil
+      info = Web::InfoProbe.call(host, port, timeout: timeout)
+      info.is_a?(Hash) ? info : nil
     end
 
     def listening?(port, host: "127.0.0.1")

data/lib/samagotchi/llm/chat_loop.rb

@@ -423,7 +423,7 @@ module Samagotchi
           end
           index = @conversation.rindex { |entry| TurnNote.retry_nudge?(entry) }
           @conversation.delete_at(index) if index
-          @cancel_controller.cancel!(:hook)
+          @cancel_controller.cancel!(:hook, response.cut)
           canceled(iteration, :hook)
         end