samagotchi 0.18.0 → 0.19.0

data/lib/samagotchi/idle_scheduler.rb

@@ -56,7 +56,7 @@ module Samagotchi
       @jobs.each do |job|
         job.tick
       rescue StandardError => e
-        Log.warn(:idle, "tick_failed", echo: "[IdleScheduler] #{job.class} tick failed: #{e.class}: #{e.message}", job: job.class.name, error: e.class.name)
+        Log.exception(:idle, "tick_failed", e, echo: "[IdleScheduler] #{job.class} tick failed: #{e.class}: #{e.message}", job: job.class.name)
       end
     end
 

data/lib/samagotchi/installed_versions.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "installed_gem"
+require_relative "version"
+
+module Samagotchi
+  # The newest chi on this machine, which a long-lived process (chi web, an
+  # attaching TUI) compares with its own VERSION to say "chi X is installed;
+  # restart". Run from an installed gem: the highest samagotchi-<v>.gemspec
+  # in RubyGems' specification dirs, matching the `>= 0.a` a new worker
+  # activates (prereleases count). Run from a source checkout: the VERSION
+  # in lib/samagotchi/version.rb on disk now (a `git pull` moves it).
+  #
+  # Cheap enough to poll: each dir is listed again only when its mtime
+  # changed, version.rb is re-read only when its mtime did, and nothing
+  # calls Gem::Specification.reset (that would disturb the running process).
+  #
+  # SAMAGOTCHI_INSTALLED_VERSION=<v> (hidden, for smokes and e2e) answers
+  # <v> instead.
+  class InstalledVersions
+    ENV_KEY = "SAMAGOTCHI_INSTALLED_VERSION"
+    GEMSPEC = /\Asamagotchi-(#{Gem::Version::VERSION_PATTERN})\.gemspec\z/
+    VERSION_LINE = /^\s*VERSION\s*=\s*["']([^"']+)["']/
+    REQUIREMENT = Gem::Requirement.new(">= 0.a")
+
+    # @param gem_spec [Gem::Specification, nil] the installed gem this code
+    #   runs from (nil: a source checkout)
+    # @param dirs [#call] → the specification dirs to list
+    # @param version_file [String] a checkout's version.rb
+    def initialize(env: ENV, gem_spec: InstalledGem.spec, dirs: -> { Gem::Specification.dirs },
+                   version_file: File.join(InstalledGem::ROOT, "lib", "samagotchi", "version.rb"))
+      @env = env
+      @gem_spec = gem_spec
+      @dirs = dirs
+      @version_file = version_file
+      @dir_cache = {}
+      @file_cache = nil
+      @mutex = Mutex.new
+    end
+
+    # @return [String, nil] the newest installed version, or nil when none
+    #   could be found out
+    def newest
+      seam = @env[ENV_KEY].to_s
+      return seam unless seam.empty?
+
+      @mutex.synchronize { @gem_spec ? newest_gem : checkout_version }
+    end
+
+    # Whether +installed+ is a newer version than +running+.
+    def self.newer?(installed, running = VERSION)
+      return false if installed.to_s.empty? || !Gem::Version.correct?(installed) || !Gem::Version.correct?(running)
+
+      Gem::Version.new(installed) > Gem::Version.new(running)
+    end
+
+    private
+
+    def newest_gem
+      @dirs.call.filter_map { |dir| dir_newest(dir) }.max&.to_s
+    end
+
+    def dir_newest(dir)
+      mtime = File.mtime(dir)
+      cached = @dir_cache[dir]
+      return cached[1] if cached && cached[0] == mtime
+
+      best = Dir.children(dir).filter_map { |name| GEMSPEC.match(name)&.[](1) }
+                .select { |v| Gem::Version.correct?(v) }
+                .map { |v| Gem::Version.new(v) }
+                .select { |v| REQUIREMENT.satisfied_by?(v) }.max
+      @dir_cache[dir] = [mtime, best]
+      best
+    rescue SystemCallError
+      @dir_cache.delete(dir)
+      nil
+    end
+
+    def checkout_version
+      mtime = File.mtime(@version_file)
+      return @file_cache[1] if @file_cache && @file_cache[0] == mtime
+
+      version = File.read(@version_file)[VERSION_LINE, 1]
+      version = nil unless version && Gem::Version.correct?(version)
+      @file_cache = [mtime, version]
+      version
+    rescue SystemCallError
+      nil
+    end
+  end
+end

data/lib/samagotchi/live_versions.rb

@@ -13,8 +13,9 @@ module Samagotchi
   module LiveVersions
     WEB_TIMEOUT = 0.5
 
-    # version is nil for a sidecar written before sidecars carried one.
-    Worker = Struct.new(:session_id, :version, keyword_init: true)
+    # version is nil for a sidecar written before sidecars carried one;
+    # restart: the worker takes `chi sessions restart` (its "restart" feature).
+    Worker = Struct.new(:session_id, :version, :restart, keyword_init: true)
 
     module_function
 
@@ -25,7 +26,8 @@ module Samagotchi
         sidecar = WorkerSidecar.live(session_dir, unlink: false)
         next unless sidecar
 
-        Worker.new(session_id: File.basename(session_dir), version: sidecar.version)
+        Worker.new(session_id: File.basename(session_dir), version: sidecar.version,
+                   restart: sidecar.features.include?("restart"))
       end
     end
 

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/memory_bundle/builder.rb

@@ -6,6 +6,7 @@ require "tmpdir"
 require_relative "manifest"
 require_relative "placeholder"
 require_relative "../memory_paths"
+require_relative "../model_overlay"
 
 module Samagotchi
   module MemoryBundle
@@ -66,7 +67,7 @@ module Samagotchi
           unless missing.empty?
             raise BuildError, "Requested file(s) not found in #{@scope} scope: #{missing.join(', ')}"
           end
-          candidates = allow.map { |k| candidates_by_basename[k] }
+          candidates = with_overlays(allow, candidates_by_basename).map { |k| candidates_by_basename[k] }
         else
           candidates = leave_out_owned(candidates, resolved_name)
         end
@@ -302,6 +303,28 @@ module Samagotchi
         end
       end
 
+      # The named files, each base followed by its model overlays
+      # (<name>.<key>.md next to it, ModelOverlay.overlay_file?; a plain
+      # tips.v2.md with no tips.md isn't one), with a note listing them. An
+      # overlay named without its base is kept, with a warning.
+      def with_overlays(allow, candidates_by_basename)
+        dir = File.dirname(candidates_by_basename.values.first.to_s)
+        overlays = candidates_by_basename.keys.select { |k| ModelOverlay.overlay_file?(File.join(dir, k)) }
+        allow.flat_map do |key|
+          if overlays.include?(key)
+            base = ModelOverlay.base_file_for(key)
+            unless allow.include?(base)
+              @warnings << "#{key} is a model overlay of #{base}, which the bundle leaves out; it loads only where #{base} exists"
+            end
+            next [key]
+          end
+
+          own = overlays.select { |k| ModelOverlay.base_file_for(k) == key && !allow.include?(k) }.sort
+          @warnings << "Included the model overlays of #{key}: #{own.join(", ")}" unless own.empty?
+          [key, *own]
+        end.uniq
+      end
+
       def normalize_filter_entry(entry)
         s = entry.to_s.strip
         # Allow with or without .md extension, but normalize to basename with .md

data/lib/samagotchi/memory_bundle/index_sync.rb

@@ -29,7 +29,7 @@ module Samagotchi
         return false unless scope && File.file?(path)
 
         name = File.basename(path, ".md")
-        return false if overlay?(path, name)
+        return false if ModelOverlay.overlay_file?(path)
 
         IndexUpdater.update_index(scope, name, File.size(path), nil)
       rescue StandardError => e
@@ -55,14 +55,6 @@ module Samagotchi
         nil
       end
 
-      def self.overlay?(path, name)
-        match = File.basename(path).match(ModelOverlay::OVERLAY_SUFFIX_PATTERN)
-        return false unless match
-
-        base = name.delete_suffix(".#{match[1]}")
-        File.file?(File.join(File.dirname(path), "#{base}.md"))
-      end
-
       def self.real(dir)
         File.realpath(dir)
       rescue SystemCallError

data/lib/samagotchi/memory_bundle/installer.rb

@@ -12,6 +12,7 @@ require_relative "merger"
 require_relative "trash"
 require_relative "../version"
 require_relative "../bundle_needs"
+require_relative "../model_overlay"
 
 module Samagotchi
   module MemoryBundle
@@ -42,6 +43,7 @@ module Samagotchi
         @warnings = []
         @placeholder_warnings = []
         @conflicts = {}
+        @overlays = []
         @trash = Trash.new(name)
       end
 
@@ -56,6 +58,7 @@ module Samagotchi
         manifest = nil
         begin
           normalized_dir, source_owned, source_commit = SourceNormalizer.normalize(@source)
+          @bundle_dir = normalized_dir
           manifest = Manifest.read(dir: normalized_dir)
         rescue SourceNormalizer::UnknownSourceError => e
           raise InstallError, "Source normalization failed: #{e.message}"
@@ -89,6 +92,7 @@ module Samagotchi
         Dir.glob(File.join(normalized_dir, "*.md")).each do |file_path|
           file_key = File.basename(file_path)
           all_files_in_bundle << file_key
+          note_overlay(file_key, target_dir)
           target_path = File.join(target_dir, file_key)
 
           if @upgrade && existing_provenance && !@force && File.exist?(target_path) && !owned_before.include?(file_key)
@@ -550,9 +554,38 @@ module Samagotchi
         dest
       end
 
+      # A model overlay (<name>.<key>.md, docs/memory.md) loads only with
+      # its base, under the matching model: it gets no index line (every
+      # model would see it as a memory of its own). Its base is looked for
+      # in the bundle dir, not the target: Dir.glob sorts tips.<key>.md
+      # before tips.md, so on a fresh install the base isn't copied yet.
+      # An overlay-looking name with no base anywhere is an overlay too,
+      # with a warning (a dry run warns as well).
+      def note_overlay(file_key, target_dir)
+        @bundle_files ||= Dir.glob(File.join(@bundle_dir, "*.md")).map { |f| File.basename(f) }
+        return unless ModelOverlay.bundle_overlay?(file_key, bundle_files: @bundle_files, target_dir: target_dir)
+
+        @overlays << file_key
+        base = ModelOverlay.base_file_for(file_key)
+        return if @bundle_files.include?(base)
+
+        @warnings << if File.file?(File.join(target_dir, base))
+                       "#{file_key} is taken as a model overlay of your #{base}, which the bundle doesn't ship; " \
+                         "it gets no index line"
+                     else
+                       "#{file_key} is a model overlay with no #{base}; it loads only once #{base} exists"
+                     end
+      end
+
       # +owned+: the bundle wrote (owns) the file, so its line says
       # "· from <bundle>"; a skipped file's line keeps whatever it had.
+      # An overlay gets none: a stale one (an earlier install's) is removed.
       def update_target_index(scope, file_path, file_key, owned: true)
+        if @overlays.include?(file_key)
+          remove_target_index(scope, file_key) if owned
+          return
+        end
+
         byte_count = File.exist?(file_path) ? File.size(file_path) : 0
         entry_name = file_key.delete_suffix(".md")
         begin

data/lib/samagotchi/memory_bundle/status.rb

@@ -6,6 +6,7 @@ require_relative "../version"
 require_relative "index_updater"
 require_relative "../memory_paths"
 require_relative "../bundle_needs"
+require_relative "../model_overlay"
 
 module Samagotchi
   module MemoryBundle
@@ -29,7 +30,9 @@ module Samagotchi
           base_checksum = File.exist?(base_path) ? Digest::SHA256.hexdigest(File.read(base_path)) : nil
           modified = base_checksum && current_checksum && base_checksum != current_checksum
           missing = !File.exist?(target_path)
-          index_present = index_has_entry?(scope, file_key_str)
+          # A model overlay has no index line (Installer#note_overlay).
+          overlay = ModelOverlay.bundle_overlay?(file_key_str, bundle_files: files.keys.map(&:to_s), target_dir: target_dir)
+          index_present = overlay ? nil : index_has_entry?(scope, file_key_str)
           details[file_key_str] = {
             conflict: meta.is_a?(Hash) && meta[:conflict] == true,
             stored_checksum: stored_checksum,
@@ -38,6 +41,7 @@ module Samagotchi
             modified: modified,
             missing: missing,
             index_present: index_present,
+            overlay: overlay,
             target_path: target_path,
             base_path: base_path
           }

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -6,6 +6,7 @@ require_relative "provenance"
 require_relative "index_updater"
 require_relative "merger"
 require_relative "trash"
+require_relative "../model_overlay"
 
 module Samagotchi
   module MemoryBundle
@@ -75,7 +76,9 @@ module Samagotchi
             next unless File.exist?(target_path)
 
             @warnings << "Kept #{file_key_str}: bundle #{others.join(", ")} has it too"
-            retag(target_scope, target_path, file_key_str, others.first)
+            unless ModelOverlay.bundle_overlay?(file_key_str, bundle_files: files.keys.map(&:to_s), target_dir: target_dir)
+              retag(target_scope, target_path, file_key_str, others.first)
+            end
             next
           end
           if File.exist?(target_path)
@@ -119,7 +122,8 @@ module Samagotchi
 
       private
 
-      # A kept shared file's index line names the bundle that still has it.
+      # A kept shared file's index line names the bundle that still has it
+      # (a model overlay has none: the caller skips it).
       def retag(scope, path, file_key, bundle)
         IndexUpdater.update_index(scope, file_key.delete_suffix(".md"), File.size(path), source: bundle)
       rescue StandardError => e

data/lib/samagotchi/model_overlay.rb

@@ -49,5 +49,44 @@ module Samagotchi
     # Regex matching overlay file names: /<something>.<lowercase-dashed-key>.md\z
     # Useful for tooling, tests, and future index suppression.
     OVERLAY_SUFFIX_PATTERN = /\.([a-z0-9\-]+)\.md\z/
+
+    # The base file name (`tips.md`) an overlay-looking name
+    # (`tips.qwen3.md`) would belong to, or nil when it doesn't match the
+    # suffix pattern.
+    def self.base_file_for(path)
+      match = File.basename(path.to_s).match(OVERLAY_SUFFIX_PATTERN)
+      return nil unless match
+
+      stem = File.basename(path.to_s).delete_suffix(match[0])
+      stem.empty? ? nil : "#{stem}.md"
+    end
+
+    # Whether +path+ is a model overlay: its name matches the suffix pattern
+    # and its base `<stem>.md` exists in one of +base_dirs+ (default: the
+    # file's own dir) or is one of +base_names+. A memory whose name has a
+    # dot and a sibling of the same stem reads as an overlay too (a
+    # leftover ambiguity).
+    def self.overlay_file?(path, base_dirs: [File.dirname(path.to_s)], base_names: [])
+      base = base_file_for(path)
+      return false unless base
+
+      base_names.map { |n| File.basename(n.to_s) }.include?(base) ||
+        base_dirs.compact.any? { |dir| File.file?(File.join(dir, base)) }
+    end
+
+    # How a bundle's installer, status and uninstaller tell an overlay
+    # (they agree, so a line the installer left out isn't "no-index"): the
+    # base is one of +bundle_files+ (basenames), or it is nowhere in
+    # +target_dir+ (an orphan overlay; it loads once the base exists).
+    # A base only in +target_dir+ (an installed memory, maybe the user's
+    # own) counts too: the installer warns, so the dot-name ambiguity
+    # (notes.v2.md next to a user's notes.md) is visible.
+    def self.bundle_overlay?(file_key, bundle_files:, target_dir:)
+      base = base_file_for(file_key)
+      return false unless base
+
+      overlay_file?(file_key, base_dirs: [target_dir], base_names: bundle_files) ||
+        !File.file?(File.join(target_dir, base))
+    end
   end
 end

data/lib/samagotchi/model_profile.rb

@@ -11,6 +11,10 @@ module Samagotchi
   #   gemma4  — Gemma 4 format
   class ModelProfile
     MODEL_ENV = "SAMAGOTCHI_DEFAULT_MODEL"
+    # Set beside MODEL_ENV for a worker spawned by a `chi --model X`: X is
+    # that run's default, not one its commands' chi should inherit
+    # (SessionManager.spawn_options, Tools::Builtins.parent_env).
+    MODEL_FROM_CLI_ENV = "SAMAGOTCHI_DEFAULT_MODEL_FROM_CLI"
     # No model anywhere (--model, default.model in config.yml, the env): a
     # first run before any config. An ArgumentError, as before.
     MissingModel = Class.new(ArgumentError)
@@ -112,7 +116,7 @@ module Samagotchi
     end
 
     def self.default
-      gemma4
+      named(DEFAULT_NAME)
     end
 
     def self.normalize(value)
@@ -124,7 +128,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/relay_desk.rb

@@ -63,6 +63,15 @@ module Samagotchi
       end
     end
 
+    # Whether a relay is open, or settled recently enough that its child
+    # may still ask about it: a restart would drop them.
+    def active?
+      @mutex.synchronize do
+        prune
+        !@relays.empty?
+      end
+    end
+
     private
 
     def prune

data/lib/samagotchi/served_model.rb

@@ -17,16 +17,26 @@ module Samagotchi
       name.is_a?(String) && !name.strip.empty? ? name : nil
     end
 
+    # The separators a provider uses when it decorates a model name: a tag
+    # (`qwen3:latest`), a date or quant suffix (`gpt-4o-2024-08-06`), an
+    # owner (`@org/name`) or a path (`meta-llama/Llama-3`). Anything else
+    # after the name is a different model (`gpt-4` is not `gpt-4o`).
+    EXTENSION_SEPARATORS = [":", "-", "@", "/"].freeze
+
     # Whether +served+ is another model than +asked+. Names that are equal
-    # (any case) or where one extends the other (a provider dropping
-    # `:free`, or adding a date) are the same model; unknown names never
-    # differ.
+    # (any case), or where one extends the other at a tag/date/owner
+    # separator (a provider dropping `:free`, or adding a date), are the
+    # same model; unknown names never differ.
     def differs?(asked, served)
       asked = asked.to_s.strip.downcase
       served = served.to_s.strip.downcase
       return false if asked.empty? || served.empty?
+      return false if asked == served
+
+      shorter, longer = asked.length <= served.length ? [asked, served] : [served, asked]
+      return true unless longer.start_with?(shorter)
 
-      !(asked.start_with?(served) || served.start_with?(asked))
+      !longer[shorter.length..].start_with?(*EXTENSION_SEPARATORS)
     end
   end
 end