samagotchi 0.17.0 → 0.18.1

data/lib/samagotchi/kernel_loop.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "iteration_limit"
 require_relative "model_profile"
 require_relative "tool_call_parser"
 require_relative "config"
@@ -174,7 +175,7 @@ module Samagotchi
     #   at the conversation tail (prefix KV cache preserved) and a
     #   :pending_input_merged stream event is emitted.
     # @return [LLM::ModelResult] final visible response with continuation metadata
-    def run(messages, max_iterations: 100, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+    def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
       @turn_settings = @turn_settings.with(model_name: completion_model_name(model_name))
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
                                   pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars))

data/lib/samagotchi/llm/backend.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require_relative "model_result"
 
 module Samagotchi
@@ -14,7 +15,7 @@ module Samagotchi
     #
     # The raw-prompt KernelLoop is NativeBackend; the chat loop is ChatLoop.
     class ModelBackend
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         raise NotImplementedError, "#{self.class}#complete must be implemented"
       end

data/lib/samagotchi/llm/chat_loop.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require "json"
 require_relative "backend"
 require_relative "model_result"
@@ -56,7 +57,7 @@ module Samagotchi
 
       def provider = :chat
 
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         raise ArgumentError, "ChatLoop has no adapter" unless @adapter
 

data/lib/samagotchi/llm/http.rb

@@ -168,7 +168,7 @@ module Samagotchi
 
       # Send +request+ and return the response with its body read.
       # @param retries [Boolean] false: one attempt, network errors raised as
-      #   is (Net::HTTP's own silent retry of an idempotent GET included)
+      #   is; either way Net::HTTP's own silent retry is off (see #start)
       # @param check_status [Boolean] false: return an error response instead
       #   of raising its ProviderError
       # @raise [RequestCancelled] when +cancel_controller+ cancels (with or
@@ -178,7 +178,7 @@ module Samagotchi
         identify(request)
         current = new_attempt_state(uri, request, log_fields, stream: false)
         attempt = lambda do |state|
-          start(uri, open_timeout: open_timeout, read_timeout: read_timeout, max_retries: retries ? nil : 0) do |http|
+          start(uri, open_timeout: open_timeout, read_timeout: read_timeout, max_retries: 0) do |http|
             state[:http] = http
             http.request(request).tap do |response|
               state[:status] = response.code.to_i
@@ -210,7 +210,13 @@ module Samagotchi
 
       def start(uri, open_timeout: nil, read_timeout: nil, max_retries: nil, &block)
         options = { open_timeout: open_timeout || @open_timeout, read_timeout: read_timeout || @read_timeout }
-        options[:max_retries] = max_retries if max_retries
+        # Net::HTTP retries an idempotent request once on its own (max_retries
+        # defaults to 1) when the connection drops before an answer: chi's
+        # RetryPolicy owns retries (and the log line says how many were sent),
+        # so every request here gets Net::HTTP's silent one off. Callers may
+        # still ask for it explicitly (a fetch whose retries: false passes 0).
+        retries = max_retries || 0
+        options[:max_retries] = retries
         options[:use_ssl] = true if uri.scheme == "https"
         Net::HTTP.start(uri.host, uri.port, **options, &block)
       end

data/lib/samagotchi/llm/native_backend.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../iteration_limit"
 require_relative "backend"
 require_relative "model_result"
 
@@ -15,7 +16,7 @@ module Samagotchi
 
       def provider = :native
 
-      def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
+      def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
         @kernel.run(
           messages,

data/lib/samagotchi/memory_bundle/trash.rb

@@ -9,13 +9,52 @@ module Samagotchi
     # (uninstall, an upgrade's dropped file): moved, never deleted, into
     # <system memories>/.bundles/.trash/<bundle>-<YYYYmmdd-HHMMSS>/, one dir
     # per operation (-2, -3… when one already has that name). A dot dir, so
-    # Provenance.each_installed never reads it as a bundle. Nothing prunes
-    # it: the user deletes it when sure.
+    # Provenance.each_installed never reads it as a bundle.
+    #
+    # `chi bundle trash` lists and empties the trash.
     class Trash
+      # A single trash entry (one directory in the trash).
+      Entry = Data.define(:name, :path, :time, :files, :bytes)
+
       def self.root(bundles_dir: MemoryPaths.bundles_dir)
         File.join(bundles_dir, ".trash")
       end
 
+      # Returns an array of {Entry} for every real directory directly inside
+      # the trash, oldest first.  A missing or empty trash gives [].
+      #
+      # +now+ is the reference time (default: Time.now); used only when a
+      # directory name has no timestamp (mtime fallback).
+      def self.entries(bundles_dir: MemoryPaths.bundles_dir, now: Time.now)
+        trash_dir = root(bundles_dir: bundles_dir)
+        return [] unless Dir.exist?(trash_dir)
+
+        Dir.children(trash_dir)
+          .select { |c| real_dir?(File.join(trash_dir, c)) }
+          .map { |name| entry_for(trash_dir, name, now) }
+          .sort_by(&:time)
+      end
+
+      # Deletes every entry that matches the filter, returning the entries
+      # that were (or would be) deleted.
+      #
+      # +older_than_days+ nil = all; a positive integer keeps newer dirs.
+      # +dry_run+ true = only return what would be deleted.
+      # +now+ reference time (default: Time.now).
+      def self.empty!(bundles_dir: MemoryPaths.bundles_dir, older_than_days: nil, now: Time.now, dry_run: false)
+        entries = self.entries(bundles_dir: bundles_dir, now: now)
+        if older_than_days
+          cutoff = now - older_than_days.to_i * 86_400
+          entries = entries.select { |e| e.time < cutoff }
+        end
+        return entries if dry_run
+
+        entries.each do |e|
+          FileUtils.rm_rf(e.path)
+        end
+        entries
+      end
+
       # The dir, once a file was moved (nil before).
       attr_reader :dir
 
@@ -52,6 +91,46 @@ module Samagotchi
         end
         @dir = candidate
       end
+
+      # Class methods below.
+
+      def self.real_dir?(path)
+        File.directory?(path) && !File.symlink?(path)
+      end
+
+      def self.entry_for(trash_dir, name, now)
+        path = File.join(trash_dir, name)
+        time = parse_timestamp(name) || File.mtime(path)
+        files, bytes = count_files(path)
+        Entry.new(name: name, path: path, time: time, files: files, bytes: bytes)
+      end
+
+      # Extracts a Time from "bundle-YYYYmmdd-HHMMSS" or "bundle-YYYYmmdd-HHMMSS-2".
+      # Returns nil if the pattern doesn't match.
+      TIMESTAMP_RE = /\A.*?-(\d{8})-(\d{6})(?:-\d+)?\z/
+
+      def self.parse_timestamp(name)
+        m = name.match(TIMESTAMP_RE)
+        return nil unless m
+
+        begin
+          Time.strptime("#{m[1]}-#{m[2]}", "%Y%m%d-%H%M%S")
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      # Recursively counts files and sums their sizes.
+      def self.count_files(dir)
+        files = 0
+        bytes = 0
+        Dir.glob(File.join(dir, "**", "*"), File::FNM_DOTMATCH).each do |f|
+          next if File.directory?(f)
+          files += 1
+          bytes += File.size(f) rescue 0
+        end
+        [files, bytes]
+      end
     end
   end
 end

data/lib/samagotchi/model_profile.rb

@@ -112,7 +112,7 @@ module Samagotchi
     end
 
     def self.default
-      gemma4
+      named(DEFAULT_NAME)
     end
 
     def self.normalize(value)
@@ -124,7 +124,7 @@ module Samagotchi
       when "gemma", "gemma4", "gemma4o"
         gemma4
       else
-        gemma4
+        named(DEFAULT_NAME)
       end
     end
 

data/lib/samagotchi/output_formatter.rb

@@ -45,13 +45,17 @@ module Samagotchi
     )
     INDIVIDUAL_RE.freeze
 
-    # Angle-bracketed literal tokens stripped wholesale (including the thought
-    # channel's trailing word). Applied before INDIVIDUAL_RE so multi-part tokens
-    # are removed as a unit.
     # Angle-bracketed literal tokens stripped wholesale (including the thought
     # channel's trailing word). Applied before INDIVIDUAL_RE so multi-part tokens
     # are removed as a unit. Pipes are escaped; angle brackets are literal.
-    LITERALS_RE = /<\|"\|>|<\|\w*channel>thought|<end_of_turn>/.freeze
+    LITERALS_RE = /<\|"\|>|<end_of_turn>/.freeze
+
+    # Gemma 4's thought channel, as a whole block: `<|channel>thought` to its
+    # `<channel|>` close, or to the end of the text when the close is missing
+    # (ToolCallParser::Gemma strips the same pair). Removing only the marker
+    # would leave the model's private reasoning in the answer; the channel is
+    # the profile's thinking lane, not output.
+    GEMMA_THOUGHT_RE = /<\|\w*channel>thought.*?(?:<channel\|>|\z)/m.freeze
 
     # Qwen prompt-literal placeholders, e.g. </think>.
     PROMPT_LITERALS = /\[\[SAMAGOTCHI_LITERAL_[A-Z_]+\]\]/.freeze
@@ -88,6 +92,7 @@ module Samagotchi
     def remove_tokens(text)
       text.to_s
           .gsub(QWEN_THINK_RE, '')
+          .gsub(GEMMA_THOUGHT_RE, '')
           .gsub(QWEN_TOOL_CALL_RE, '')
           .gsub(LITERALS_RE, '')
           .gsub(INDIVIDUAL_RE, '')

data/lib/samagotchi/parent_report.rb

@@ -31,8 +31,10 @@ module Samagotchi
     module_function
 
     # @param result [ReplyWait::Result]
-    # @return [String] answered, question, failed, canceled, no_answer,
-    #   error, worker_gone, stopped or running
+    # @return [String] answered, question, failed, canceled, limit (the
+    #   turn ran out of iterations, nobody asked), not_continued (a Stop
+    #   answered the step-limit question), no_answer, error, worker_gone,
+    #   stopped or running
     def status(result)
       case result.status
       when :done then "answered"
@@ -41,6 +43,8 @@ module Samagotchi
         case result.outcome
         when "failed" then "failed"
         when "canceled" then "canceled"
+        when "exhausted" then "limit"
+        when "not_continued" then "not_continued"
         else "no_answer"
         end
       when :error then "error"
@@ -52,11 +56,12 @@ module Samagotchi
       end
     end
 
-    # @return [Integer] 0 answered, 3 a question waits, 4 still running,
-    #   1 anything else
+    # @return [Integer] 0 answered (or not continued: the Stop asked for
+    #   was carried out), 3 a question waits, 4 still running, 1 anything
+    #   else
     def exit_status(result)
       case status(result)
-      when "answered" then CLI::Exit::OK
+      when "answered", "not_continued" then CLI::Exit::OK
       when "question" then CLI::Exit::QUESTION
       when "running" then CLI::Exit::RUNNING
       else CLI::Exit::FAILED
@@ -116,7 +121,8 @@ module Samagotchi
 
     # A pending question (Session#pending_question) as a parent sees it.
     # kind is "question" for the model's own (the desk stores none),
-    # "hook" or "approval".
+    # "hook", "approval" or "continue" (the step-limit question, with the
+    # turn's limit).
     # @return [Hash]
     def question(pending)
       pending ||= {}
@@ -129,15 +135,18 @@ module Samagotchi
         options: Array(pending[:options]).map(&:to_s),
         multi_select: !!pending[:multi_select],
         allow_freeform: !!pending[:allow_freeform],
+        limit: pending[:limit],
         approval: approval&.slice(*APPROVAL_KEYS)
       }.compact
     end
 
     # The command that answers +question+; N is the parent's to fill in.
     # An approval's is a deny: allowing it is the user's
-    # (Guardrails::ParentApprovals).
+    # (Guardrails::ParentApprovals). A step-limit question's continues the
+    # turn (its Stop form is in #question_text).
     def answer_with(session_id, question)
       return "chi answer #{session_id} --question #{question[:id]} --option Deny --text WHY" if approval?(question)
+      return "chi answer #{session_id} --question #{question[:id]} --option Continue" if continue?(question)
 
       "chi answer #{session_id} --question #{question[:id]} --option N"
     end
@@ -156,6 +165,16 @@ module Samagotchi
       question.is_a?(Hash) && (question[:kind] || question["kind"]).to_s == "approval"
     end
 
+    # The step-limit question (ContinueOffer).
+    def continue?(question)
+      question.is_a?(Hash) && (question[:kind] || question["kind"]).to_s == "continue"
+    end
+
+    # What a message does to a step-limit question.
+    def message_drops(session_id)
+      "a message instead (chi send #{session_id} -m …) drops it and starts a new turn"
+    end
+
     # What a wait that ended without an answer says, one line.
     def detail(result, session_id:, timeout: nil)
       attach = "chi --attach #{session_id}"
@@ -163,10 +182,13 @@ module Samagotchi
       when :waiting_for_answer
         if approval?(result.question)
           "waiting for an approval: #{first_line(result.question[:question])}; #{DENY_AND_TELL}"
+        elsif continue?(result.question)
+          "waiting at the step limit: #{first_line(result.question[:question])}; " \
+            "answer Continue or Stop: chi answer #{session_id} --question #{result.question[:id]} --option Continue"
         else
           "waiting for an answer: #{first_line(result.question&.dig(:question))}; open it: #{attach} or the web"
         end
-      when :no_reply then "#{no_reply_line(result)}; #{attach} shows it"
+      when :no_reply then "#{no_reply_line(result, session_id)}; #{attach} shows it"
       when :error then "the worker failed: #{result.text}; #{attach} shows what happened"
       when :worker_gone then "the worker is gone; #{attach} shows what happened"
       when :stopped then "the session was stopped (chi sessions stop)"
@@ -188,6 +210,10 @@ module Samagotchi
         lines << "  allowing it is up to your user: #{DENY_AND_TELL}"
         lines << "  deny: #{answer_with(session_id, q)}"
         lines << "  #{leave_open(session_id)}"
+      elsif continue?(q)
+        lines << "  continue: #{answer_with(session_id, q)}"
+        lines << "  stop: chi answer #{session_id} --question #{q[:id]} --option Stop --text WHY (the text is optional; the model reads it)"
+        lines << "  #{message_drops(session_id)}"
       else
         lines << "  more than one allowed: repeat --option" if q[:multi_select]
         lines << "  free text allowed: --text" if q[:allow_freeform]
@@ -197,11 +223,15 @@ module Samagotchi
       lines.map { |line| "#{line}\n" }.join
     end
 
-    def no_reply_line(result)
+    def no_reply_line(result, session_id = nil)
       case result.outcome
       when "failed" then result.text.to_s.strip.empty? ? "the turn failed" : "the turn failed: #{result.text.strip}"
       when "canceled" then "the turn was canceled"
       when "completed" then "the turn ended with no visible answer"
+      when "not_continued" then "the turn was not continued (Stop); its work so far stays"
+      when "exhausted"
+        "the turn ran out of iterations#{" (#{result.limit} steps)" if result.limit} before it answered; " \
+          "chi send #{session_id} -m '/continue yes' continues it, a message drops it"
       else "the turn ended without a reply (canceled, failed or empty)"
       end
     end