samagotchi 0.7.0 → 0.8.1

data/lib/samagotchi/guardrails/targets.rb

@@ -3,6 +3,7 @@
 require_relative "../tools/tool_path"
 require_relative "../tools/memory"
 require_relative "../log"
+require_relative "model_size"
 
 module Samagotchi
   module Guardrails
@@ -16,6 +17,10 @@ module Samagotchi
 
       attr_reader :tool, :command, :paths, :cwd, :repo_root
 
+      # @return [String, nil] the effective model: its bare name (no host
+      #   prefix) and its key (ModelOverlay.key_for), for a rule's models:
+      attr_reader :model_name, :model_key
+
       # @return [Hash, nil] a plugin tool's arguments (call[:args]), for an
       #   approval of a call whose targets name no command or path; nil for
       #   chi's own tools
@@ -23,10 +28,12 @@ module Samagotchi
 
       # @param call [Hash] the parsed tool call
       # @param context [Context]
-      # @param model_key [String, nil] for a memory_write model overlay
+      # @param model_key [String, nil] for a memory_write model overlay, and
+      #   a rule's models:
+      # @param model_name [String, nil] the bare model name, for a rule's models:
       # @param registry [Tools::Registry, nil] the session's tools: a plugin
       #   tool's entry says what it acts on (its targets:)
-      def self.for(call, context, model_key: nil, registry: nil)
+      def self.for(call, context, model_key: nil, model_name: nil, registry: nil)
         tool = call[:name].to_s
         base = context.cwd
         command = nil
@@ -53,7 +60,8 @@ module Samagotchi
           entry = registry && registry[tool]
           args = call[:args] if entry && !entry.core? && call[:args].is_a?(Hash)
         end
-        new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd), args: args)
+        new(tool: tool, command: command, paths: paths.compact, cwd: cwd, repo_root: context.repo_root(cwd), args: args,
+            model_name: model_name, model_key: model_key)
       end
 
       # What a plugin tool's targets: callable says the call acts on:
@@ -93,8 +101,10 @@ module Samagotchi
         nil
       end
 
-      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil)
+      def initialize(tool:, command:, paths:, cwd:, repo_root:, args: nil, model_name: nil, model_key: nil)
         @args = args
+        @model_name = model_name
+        @model_key = model_key
         @tool = tool
         @command = command
         @paths = paths
@@ -104,6 +114,14 @@ module Samagotchi
 
       def shell? = SHELL_TOOLS.include?(@tool)
 
+      # Whether the effective model is a small one (guardrails.small_models,
+      # read when first asked: once per call's targets).
+      def small_model?
+        return @small_model if defined?(@small_model)
+
+        @small_model = ModelSize.small?(@model_name, @model_key)
+      end
+
       # Whether any path is outside the repo root (the cwd outside a repo).
       def outside_repo?
         root = @repo_root || @cwd

data/lib/samagotchi/guardrails.rb

@@ -3,6 +3,7 @@
 require_relative "guardrails/verdict"
 require_relative "guardrails/context"
 require_relative "guardrails/targets"
+require_relative "guardrails/model_size"
 require_relative "guardrails/approval"
 require_relative "guardrails/approvals"
 require_relative "guardrails/protected_paths"

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
 

data/lib/samagotchi/llm/native_backend.rb

@@ -32,17 +32,17 @@ module Samagotchi
           pending_input: pending_input
         )
         ModelResult.new(
-          text: kernel_result.respond_to?(:output) ? kernel_result.output.to_s : kernel_result.to_s,
+          text: kernel_result.output.to_s,
           tool_calls: nil,
           provider: :native,
           usage: usage.usage(prompt_text: Array(messages).sum("") { |message| message[:content].to_s }),
-          conversation: kernel_result.respond_to?(:conversation) ? kernel_result.conversation : nil,
-          canceled: kernel_result.respond_to?(:canceled?) && kernel_result.canceled?,
-          cancellation_reason: kernel_result.respond_to?(:cancellation_reason) ? kernel_result.cancellation_reason : nil,
-          exhausted: kernel_result.respond_to?(:exhausted) && kernel_result.exhausted,
-          tool_activity: kernel_result.respond_to?(:tool_activity) ? kernel_result.tool_activity : [],
-          context_status: kernel_result.respond_to?(:context_status) ? kernel_result.context_status : nil,
-          pending_tool_calls: kernel_result.respond_to?(:pending_tool_calls) && kernel_result.pending_tool_calls
+          conversation: kernel_result.conversation,
+          canceled: kernel_result.canceled?,
+          cancellation_reason: kernel_result.cancellation_reason,
+          exhausted: kernel_result.exhausted,
+          tool_activity: kernel_result.tool_activity,
+          context_status: kernel_result.context_status,
+          pending_tool_calls: kernel_result.pending_tool_calls
         )
       end
     end