samagotchi 0.93.0 → 0.95.0

data/lib/samagotchi/host_config.rb

@@ -13,13 +13,13 @@ module Samagotchi
   # one).
   #
   # name: the lowercased entry name; host, port, scheme: where it is (from
-  # url: when given); url: the configured url, nil when host/port; transport,
-  # api: symbols, nil when unset; auth: the header the API key goes in
+  # url: when given); url: the configured url, nil when host/port; api: a
+  # symbol, nil when unset (llama_cpp's raw-prompt loop); auth: the header the API key goes in
   # (LLM::ApiKey::SCHEMES), nil when unset; dialect: an api: anthropic
   # host's LLM::Dialect name, nil when unset; the rest as
   # HostRegistry::HostEntry describes them, nil when unset; models:
   # {downcased id => HostModel}.
-  HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :auth, :dialect, :profile,
+  HostConfig = Data.define(:name, :host, :port, :scheme, :url, :api, :api_key_env, :auth, :dialect, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
                            :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models) do
@@ -79,10 +79,10 @@ module Samagotchi
         ConfigFile.warn_once "Warning: #{where}: auth has no effect without api_key_env (no key is sent)"
       end
 
-      kinds = parse_kinds(name, value.call(:transport), value.call(:api)) or return nil
-      location = parse_location(name, value, api: kinds[:api]) or return nil
-      fields[:dialect] = LLM::Dialect.parse(value.call(:dialect), where, api: kinds[:api])
-      new(name: name.downcase, **location, **kinds, **fields)
+      kind = parse_api(name, value.call(:api), value.call(:transport)) or return nil
+      location = parse_location(name, value, api: kind[:api]) or return nil
+      fields[:dialect] = LLM::Dialect.parse(value.call(:dialect), where, api: kind[:api])
+      new(name: name.downcase, **location, **kind, **fields)
     rescue StandardError => e
       # One entry that trips a reader is dropped on its own, and said so;
       # the other hosts stay (the worker's copy too).
@@ -143,29 +143,22 @@ module Samagotchi
     end
     private_class_method :parse_location
 
-    # transport: and api: as symbols; a raw-prompt api is also the
-    # transport. nil (warned) when unknown or contradicting each other.
-    def self.parse_kinds(name, transport, api)
-      transport = transport.to_s.strip.downcase
-      if transport.empty?
-        transport = nil
-      elsif !ConfigFile::VALID_TRANSPORTS_FOR_CONFIG.include?(transport)
-        return invalid(name, "unknown transport '#{transport}'")
+    # { api: } (a symbol, nil when not given), or nil (warned) when the api
+    # is unknown. A removed api (RemovedApi) in api: or in the old
+    # transport: key leaves the entry out with its line; any other
+    # transport: is only warned about at start
+    # (ConfigFile.removed_transport_problem).
+    def self.parse_api(name, api, transport)
+      %w[api transport].zip([api, transport]).each do |key, written|
+        return invalid(name, ConfigFile::RemovedApi.new("hosts.#{name}.#{key}", written.to_s.strip).message) if ConfigFile.removed_api?(written)
       end
       api = api.to_s.strip.downcase
-      if api.empty?
-        api = nil
-      elsif !ConfigFile::VALID_APIS_FOR_CONFIG.include?(api)
-        return invalid(name, "unknown api '#{api}'")
-      elsif ConfigFile::VALID_TRANSPORTS_FOR_CONFIG.include?(api)
-        # A raw-prompt api is the transport; a different transport contradicts it.
-        return invalid(name, "api '#{api}' conflicts with transport '#{transport}'") if transport && transport != api
-
-        transport = api
-      end
-      { transport: transport&.to_sym, api: api&.to_sym }
+      return { api: nil } if api.empty?
+      return invalid(name, "unknown api '#{api}'") unless ConfigFile::VALID_APIS_FOR_CONFIG.include?(api)
+
+      { api: api.to_sym }
     end
-    private_class_method :parse_kinds
+    private_class_method :parse_api
 
     def self.invalid(name, reason)
       ConfigFile.warn_once "Warning: ignoring hosts entry '#{name}': #{reason}"

data/lib/samagotchi/host_registry.rb

@@ -10,7 +10,7 @@ require_relative "llm/adapters"
 require_relative "llm/dialect"
 
 module Samagotchi
-  # HostRegistry manages multiple model hosts (llama.cpp / mlx / oMLX) and
+  # HostRegistry manages multiple model hosts (llama.cpp, OpenAI-compatible, Anthropic) and
   # provides lazy model discovery aggregation.
   #
   # - Hosts are defined in config.yml `hosts:` section or synthesized from
@@ -46,7 +46,7 @@ module Samagotchi
     # llm_context_apply: the configured apply rule (LLMContextStrategy), nil when unset;
     # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
     # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
-    HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :auth, :dialect,
+    HostEntry = Struct.new(:name, :host, :port, :client, :api, :scheme, :url, :api_key_env, :auth, :dialect,
                            :profile, :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
                            :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models, keyword_init: true) do
@@ -126,7 +126,7 @@ module Samagotchi
         # Every HostConfig field is a HostEntry member (a new one must be added there too).
         fields = cfg.to_h.merge(name: key.to_s.downcase, port: cfg.port.to_i, api: cfg.api&.to_sym, models: cfg.models || {})
         entry = HostEntry.new(**fields)
-        entry.client = Client.new(host: cfg.host, port: cfg.port, transport: cfg.transport, scheme: cfg.scheme,
+        entry.client = Client.new(host: cfg.host, port: cfg.port, scheme: cfg.scheme,
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
                                   api_key_env: entry.api_key_env, auth: entry.auth_scheme, env: env)
         @entries[entry.name] = entry
@@ -137,7 +137,7 @@ module Samagotchi
         host = "localhost" if host.empty?
         port = Config.get("server.port").to_i
         port = 8080 if port <= 0
-        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, transport: nil, models: {},
+        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, models: {},
                                             client: Client.new(host: host, port: port, name: "default"))
       end
       @mutex = Mutex.new
@@ -341,7 +341,7 @@ module Samagotchi
     end
 
     # List models on all hosts in parallel. On error per-host, skip with error entry (no failover).
-    # Returns { host_name => { host:, port:, transport:, models: [LLM::ModelInfo], error: nil|String } }
+    # Returns { host_name => { host:, port:, models: [LLM::ModelInfo], error: nil|String } }
     # Also populates the model index. Unless forced, a host's list is reused
     # for its TTL (60s; 10 minutes for a remote host).
     #
@@ -361,12 +361,12 @@ module Samagotchi
         Thread.new do
           begin
             models = list_models_for(entry)
-            data = { host: entry.host, port: entry.port, transport: entry.transport, models: models, error: nil }
+            data = { host: entry.host, port: entry.port, models: models, error: nil }
             @mutex.synchronize { @host_lists[name] = { data: data, at: @clock.call } }
             save_model_list(name, models)
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
-            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: list_error(e) }
+            data = { host: entry.host, port: entry.port, models: [], error: list_error(e) }
           end
           results_mutex.synchronize { results[name] = data }
         end
@@ -380,7 +380,7 @@ module Samagotchi
           @entries.each_with_object({}) do |(name, entry), acc|
             acc[name] = results.fetch(name) do
               partial = true
-              { host: entry.host, port: entry.port, transport: entry.transport, models: [],
+              { host: entry.host, port: entry.port, models: [],
                 error: "no answer in #{wait == wait.to_i ? wait.to_i : wait} s" }
             end
           end

data/lib/samagotchi/kernel_loop.rb

@@ -193,7 +193,7 @@ module Samagotchi
     attr_accessor :llm_context_turn
     # @return [Integer, nil] the llama.cpp slot (`id_slot`) the last
     #   request of the last run streamed from; nil when the server named
-    #   none (other transports) or no request was made
+    #   none or no request was made
     attr_reader :last_slot
 
     # Run the conversation loop and return the final model response plus
@@ -294,8 +294,8 @@ module Samagotchi
     Request = Struct.new(:prompt, :images, :image_tokens, :window, :prefill, keyword_init: true)
     # One generation: the response (nil when cut), the cut's detail, this
     # generation's own server counts, the model the server named, the
-    # thinking it streamed, and why it stopped (the transport's finish
-    # reason, Client::Transport#finish_reason_from; nil when not named),
+    # thinking it streamed, and why it stopped (llama.cpp's finish
+    # reason, Client.finish_reason_from; nil when not named),
     # and its prompt-cache counts (the largest seen: they come cumulative),
     # and where its visible text starts in the turn's buffer.
     Generation = Struct.new(:response, :cut, :usage, :served_model, :streamed_thinking, :finish_reason, :cache,
@@ -312,15 +312,32 @@ module Samagotchi
         empty_retry: EmptyAnswerRetry.new, empty_steps: [], tool_activity: [], buffer: +"", streamed_thinking: +"",
         qwen_attempts: 0, qwen_partial: nil,
         # 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
-        # prompt starts with what the server already has cached.
-        prefill: Thinking.native(@turn_settings.thinking || Thinking::DEFAULT, @profile).prefill,
+        # answers at once; on, an open one where the server's template has
+        # it. Kept in the turn's model messages, so each tool-loop prompt
+        # starts with what the server already has cached.
+        prefill: native_prefill(@turn_settings.thinking || Thinking::DEFAULT),
         pending_tool_calls: false, model_name: @turn_settings.model_name, pending_input: pending_input,
         on_stream_event: on_stream_event, cancel_controller: cancel_controller, cap: cap,
         emit: emit
       )
     end
 
+    # The text after the cue for +level+ (Thinking.native), set once per
+    # turn. Only qwen36 with thinking on asks the server's template whether
+    # it opens a thought: the /props answer the profile and the window
+    # probes cached (no template, as a router's own /props or a failed
+    # probe: no open thought, the prompt as before).
+    def native_prefill(level)
+      opens = @profile&.name == "qwen36" && level != :off && Thinking.opens_thought?(model_props)
+      Thinking.native(level, @profile, opens_thought: opens).prefill
+    end
+
+    def model_props
+      @client.respond_to?(:server_props) ? @client.server_props(model: @turn_settings.model_name) : nil
+    rescue StandardError
+      nil
+    end
+
     # One iteration. Returns :next, :answer (the turn ends), or the turn's
     # result (it ended cancelled).
     def iterate(turn)
@@ -336,13 +353,28 @@ module Samagotchi
       # Profile-specific parse (incl. Qwen unterminated-block recovery); the
       # returned fragment (non-nil only for Qwen) is fed back on the next
       # iteration if the model opened a tool-call block it did not close.
-      calls, turn.qwen_partial = parser.parse_with_recovery(generation.response, turn.qwen_partial)
+      calls, turn.qwen_partial = parser.parse_with_recovery(callable_text(request, generation), turn.qwen_partial)
       calls = calls.map { |call| PromptLiteralGuard.restore_call(call, profile: @profile) }
       return after_text(turn, request, generation) if calls.empty?
 
       dispatch_calls(turn, calls)
     end
 
+    # The reply's text the tool-call parse reads: with a closed thought
+    # (Qwen's </think>, the prefill's open thought included), what is left
+    # without its thought blocks, so a call the model only thought about
+    # neither runs nor asks for a recovery (the UIs show it as thinking).
+    # A thought never closed stays: a model that writes its call there
+    # still has it run. The model message keeps the whole reply.
+    def callable_text(request, generation)
+      response = generation.response.to_s
+      close = @profile.thought_close
+      full = request.prefill + response
+      return response unless close && full.include?(close)
+
+      strip_thought_blocks(full)
+    end
+
     # The prompt for this iteration, after the context check: a rise into a
     # bucket that asks the model for a change puts its line on the tail
     # (the prompt cache keeps its prefix), and the prompt is formatted again
@@ -427,6 +459,10 @@ module Samagotchi
         # thinking) leaves the splitter inside that block, so rebuilding it
         # keeps the restarted stream's prose in the right lane.
         stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
+        # The prompt's prefill is the reply's start: an open thought there
+        # streams as thinking. What the seed itself splits into is the
+        # prompt's, not shown.
+        stream_splitter.feed(request.prefill) unless request.prefill.empty?
         # Each ask starts with streamed_any = false, but once any chunk of
         # this ask is shown it stays shown: a held-back partial marker after
         # real text must not clear it, or the drop below won't ask again.
@@ -635,7 +671,9 @@ module Samagotchi
         return :next
       end
 
-      response = generation.response
+      # The prefill is the reply's start: an open thought it began closes in
+      # the response, and the whole block goes from the answer.
+      response = request.prefill + generation.response.to_s
       answer = -> { PromptLiteralGuard.restore(strip_thought_blocks(response), profile: @profile) }
       empty = strip_thought_blocks(response.to_s).strip.empty?
       retry_empty = empty && turn.empty_retry.retry_empty?(iteration: turn.iteration,

data/lib/samagotchi/memory_bundle/profile.rb

@@ -25,9 +25,14 @@ module Samagotchi
     # shipped meta expands: includes: in any other bundle is ignored.
     module Profile
       # installed: members installed now; already: members found installed
-      # (recorded, not reinstalled); skipped and failed: name => why.
-      InstallResult = Struct.new(:name, :version, :installed, :already, :skipped, :failed, keyword_init: true) do
+      # (recorded, not reinstalled); skipped and failed: name => why;
+      # kept_own: member installed now => its memory files the user already
+      # had, left as they are and not owned (Installer#skip_existing).
+      InstallResult = Struct.new(:name, :version, :installed, :already, :skipped, :failed, :kept_own, keyword_init: true) do
         def failed? = !failed.empty?
+
+        # One line per kept file (Profile.kept_own_line).
+        def kept_own_lines = (kept_own || {}).flat_map { |member, files| files.map { |file| Profile.kept_own_line(member, file) } }
       end
       # removed: members uninstalled; blocked: name => why; gone: the meta
       # itself was removed (only once every member is); trash: member =>
@@ -69,6 +74,15 @@ module Samagotchi
 
       def installed_names = Provenance.each_installed.map { |name, _| name }
 
+      # What a profile's install says of a member's memory file the user
+      # already had: chi bundle install says "Skipped … (already exists)",
+      # which a profile's member install would leave unsaid (docs/memory.md,
+      # "Shipped notes").
+      def kept_own_line(member, file)
+        "#{member}: kept your own #{file} (not the bundle's; to take the bundle's, remove yours with " \
+          "memory_write remove: true, then chi bundle install #{member})"
+      end
+
       # The one rule.
       def to_install(manifest, bundle = Provenance.new(name: manifest.name).record, installed: installed_names)
         manifest.includes - recorded(bundle, manifest) - installed
@@ -84,7 +98,7 @@ module Samagotchi
         was = recorded(bundle, manifest)
         installed = installed_names
         result = InstallResult.new(name: manifest.name, version: manifest.version, installed: [],
-                                   already: (manifest.includes - was) & installed, skipped: {}, failed: {})
+                                   already: (manifest.includes - was) & installed, skipped: {}, failed: {}, kept_own: {})
 
         to_install(manifest, bundle, installed: installed).each do |member|
           install_member(member, shipped_dir, chi_version, dry_run, force, result)
@@ -109,8 +123,12 @@ module Samagotchi
         return result.skipped[member] = failure if failure
         return result.installed << member if dry_run
 
-        Installer.new(source: member_dir, name: member, scope: "system", force: force, strict: true, shipped_dir: shipped_dir).run
+        installer = Installer.new(source: member_dir, name: member, scope: "system", force: force, strict: true,
+                                  shipped_dir: shipped_dir)
+        installer.run
         result.installed << member
+        kept = installer.results.select { |_, entry| entry[:status] == "skipped" && entry[:reason] == "already exists" }.keys
+        result.kept_own[member] = kept.sort unless kept.empty?
       rescue StandardError => e
         result.failed[member] = e.message.lines.first.to_s.strip
       end

data/lib/samagotchi/memory_bundle/shipped_update.rb

@@ -37,7 +37,10 @@ module Samagotchi
       # :failed. note says why for skipped/failed. kept and replaced are
       # file names; under plan they are what apply would keep or replace.
       # adds is nil but for a profile: the members it installs.
-      Row = Struct.new(:name, :from, :to, :status, :note, :kept, :replaced, :source_dir, :scope, :adds, keyword_init: true)
+      # kept_own is nil but for a profile that installed a member: its
+      # Profile.kept_own_line lines.
+      Row = Struct.new(:name, :from, :to, :status, :note, :kept, :replaced, :source_dir, :scope, :adds, :kept_own,
+                       keyword_init: true)
 
       module_function
 
@@ -84,6 +87,7 @@ module Samagotchi
         result = Profile.install(row.source_dir, shipped_dir: File.dirname(row.source_dir))
         row.dup.tap do |r|
           r.adds = result.installed
+          r.kept_own = result.kept_own_lines
           r.status = result.failed? ? :failed : :updated
           r.note = result.failed.map { |member, why| "#{member}: #{why}" }.join("; ") if result.failed?
         end

data/lib/samagotchi/model_profile.rb

@@ -484,12 +484,11 @@ module Samagotchi
     private_class_method :configured
 
     # Only a native llama.cpp host has /props with a chat template; a chat
-    # host (api: openai or anthropic) barely uses a profile, and mlx/oMLX expose none.
+    # host (api: openai or anthropic) barely uses a profile.
     def self.probe?(entry, client)
       return false if client.nil? || !client.respond_to?(:server_props)
-      return false if entry&.chat?
 
-      client.transport.name == :llama_cpp
+      !entry&.chat?
     end
     private_class_method :probe?
 

data/lib/samagotchi/self_report.rb

@@ -345,8 +345,6 @@ module Samagotchi
       when :config then "#{name} (config #{result.detail})"
       when :cli, :env then "#{name} (#{result.source})"
       else
-        return "#{name} (#{result.source})" unless entry.nil? || entry.transport.nil? || entry.transport == :llama_cpp
-
         given = result.source == :name ? "name says #{name}" : "default #{name}"
         "from the server at runtime (#{given})"
       end

data/lib/samagotchi/system_prompt.rb

@@ -96,7 +96,7 @@ module Samagotchi
         @section_notes = nil
         @section_files = []
         @built[key] = system_prompt_with_index(
-          assist_system_prompt(chat: chat, thinking: thinking, layers: layers), chat: chat, thinking: thinking, layers: layers
+          assist_system_prompt(chat: chat, layers: layers), chat: chat, thinking: thinking, layers: layers
         )
         @index_sizes[key] = @measured_index
         @notes_loaded[key] = @section_notes || []
@@ -151,9 +151,8 @@ module Samagotchi
 
     # The base prompt (specs, plugins' declarations), with Gemma's tool
     # declarations at its end as #build has them.
-    def base(chat: false, thinking: nil, layers: [])
-      with_tail_declarations(assist_system_prompt(chat: chat, thinking: thinking, layers: layers), chat: chat,
-                                                                                                  layers: layers)
+    def base(chat: false, layers: [])
+      with_tail_declarations(assist_system_prompt(chat: chat, layers: layers), chat: chat, layers: layers)
     end
 
     # Names activated via preloaded --memory entries during prompt
@@ -195,27 +194,14 @@ module Samagotchi
       end
     end
 
-    # Only Qwen has an explicit thinking-close marker, so only Qwen can
-    # reliably have this preamble parsed back out of its thinking block.
-    # With thinking off there is no thinking to begin with it.
-    def turn_preamble_instruction(thinking = nil)
-      return "" unless profile.name == "qwen36"
-      return "" if Samagotchi::Config.get("thinking.turn_preamble") == false
-      return "" if (thinking || turn_thinking) == :off
-
-      "\nTurn preamble: as the very first line of your thinking, write \"TURN: \" followed by a short present-tense action phrase (max 8 words) describing what you are about to do, e.g. \"TURN: reading project config\". Then continue reasoning normally.\n"
-    end
-
     # ── System prompts ─────────────────────────────────────────────────────────
 
-    # @param chat [Boolean] for the chat loop: no tool declarations, call
-    #   syntax or turn preamble (its tools go as schemas with each request)
-    # @param thinking [Symbol, nil] the level (Thinking); nil: the effective model's
-    def assist_system_prompt(chat: false, thinking: nil, layers: [])
+    # @param chat [Boolean] for the chat loop: no tool declarations or call
+    #   syntax (its tools go as schemas with each request)
+    def assist_system_prompt(chat: false, layers: [])
       return chat_system_prompt if chat
 
       hint = tool_call_hint
-      turn_preamble = turn_preamble_instruction(thinking)
       # Gemma 4's template declares the tools at the end of the system turn
       # (#system_prompt_with_index puts them there).
       tools = if gemma_tail_declarations?
@@ -228,7 +214,7 @@ module Samagotchi
         You are Chi (pronounced "chee"), the friendly name for the Samagotchi assistant harness. #{tools}
         #{hint}
         You may make multiple tool calls. After seeing tool results, continue reasoning or answer the user.
-        #{turn_preamble}
+
         #{ToolDeclarations::SMALL_CONTEXT_PROTOCOL}
 
         #{assist_guidance}

data/lib/samagotchi/terminal_ui/thinking_line.rb

@@ -20,8 +20,6 @@ module Samagotchi
 
       # Enough text to find the newest sentence in; scanning grows with it.
       BUFFER_LIMIT = 2000
-      # The Qwen turn preamble's first line ("TURN: reading the config").
-      TURN_PREFIX = /\ATURN:\s*/i
       # Where a raw stream's thinking ends: a boundary, so its last words
       # don't run into the answer's first.
       THOUGHT_CLOSE = %r{<channel\|>|</think>}
@@ -65,8 +63,8 @@ module Samagotchi
       # @return [Symbol, nil] :thinking or :writing
       attr_reader :label
 
-      # The sentence as a row shows it: no TURN: prefix, markdown plain.
-      def sentence = strip_markdown(@ticker.line.sub(TURN_PREFIX, ""))
+      # The sentence as a row shows it: markdown plain.
+      def sentence = strip_markdown(@ticker.line)
 
       # #sentence cut to +room+ columns, with an ellipsis when cut.
       def fit(room)

data/lib/samagotchi/testing/sandbox.rb

@@ -124,6 +124,32 @@ module Samagotchi
         File.join(memory_dir(scope, cwd: cwd || Dir.pwd), "#{name}.md")
       end
 
+      # The model notes chi loads into the prompt for +model_id+ (the bare
+      # id, no host prefix: `deepseek/deepseek-v4.1-flash`), from this
+      # sandbox's memories (the system scope's, then the project scope's for
+      # the checkout at +cwd+), matched as chi matches them: each `models:`
+      # glob against the id and its model key.
+      # @param small [Boolean, nil] whether the model counts as a small one
+      #   for a `small` entry; nil: chi's own rule (guardrails.small_models)
+      # @return [Array<#name, #scope, #chars, #body>] the notes in prompt
+      #   order (`.map(&:name)` for the names); none: []
+      def model_notes_for(model_id, small: nil, cwd: nil)
+        require_relative "../model_notes"
+        require_relative "../model_overlay"
+        small_check = small.nil? ? nil : -> { small }
+        in_dir(cwd) do
+          ModelNotes.for(name: model_id, key: ModelOverlay.key_for(model_id), small: small_check, warn: false)
+        end
+      end
+
+      # The sizes chi warns over (it still loads the notes): one note's
+      # body (+:note+) and all of a model's notes (+:total+), in chars.
+      # @return [Hash{Symbol => Integer}]
+      def model_note_limits
+        require_relative "../model_notes"
+        { note: ModelNotes::NOTE_LIMIT, total: ModelNotes::TOTAL_LIMIT }
+      end
+
       # @return [String] a temp folder for the session's cwd
       def work_dir = File.join(@root, "work")
 

data/lib/samagotchi/thinking.rb

@@ -27,6 +27,14 @@ module Samagotchi
     # An empty thought after the Qwen assistant cue: the model answers at once
     # (what the server's own template does with enable_thinking false).
     QWEN_EMPTY_THOUGHT = "<think>\n\n</think>\n\n"
+    # An open thought after the Qwen assistant cue, as a Qwen3.5+ template
+    # writes it with thinking on: without it Qwen3.6 writes an empty thought
+    # at once and never thinks (#opens_thought?).
+    QWEN_OPEN_THOUGHT = "<think>\n"
+    # A Jinja string literal that ends with the open thought: '<think>\n'
+    # (a Qwen3.5+ generation prompt). Qwen3's writes only the empty one,
+    # '<think>\n\n</think>\n\n', with thinking off.
+    OPEN_THOUGHT_LITERAL = /<think>(?:\\n|\n)['"]/
     # Gemma 4's empty thought channel after the model cue, as its chat
     # template writes it with enable_thinking false (only where a model turn
     # starts: Prompt.prefill_for).
@@ -168,15 +176,40 @@ module Samagotchi
       caps.is_a?(Hash) && caps["supports_reasoning_effort"] == false
     end
 
+    # Whether a llama.cpp /props answer (+props+, Client::ServerProps)
+    # carries a chat template whose generation prompt opens a thought
+    # (Qwen3.5 and later: `assistant\n` then '<think>\n' unless
+    # enable_thinking is false). Read from the template's last
+    # add_generation_prompt branch on: the message loop before it writes
+    # earlier turns' thoughts. false when there is no template (a router's
+    # own /props, an unloaded model, a failed probe).
+    def opens_thought?(props)
+      return false unless props.respond_to?(:answered?) && props.answered? && props.body.is_a?(Hash)
+
+      template = props.body["chat_template"]
+      return false unless template.is_a?(String)
+
+      cue = template.rindex("add_generation_prompt")
+      !cue.nil? && OPEN_THOUGHT_LITERAL.match?(template[cue..])
+    end
+
     # The native prompt's switch for +level+ under +profile+.
     # @param profile [ModelProfile]
+    # @param opens_thought [Boolean] the server's template opens a thought
+    #   after the cue (#opens_thought?): qwen36 then gets the open thought
+    #   at every level but off, as the template has it
     # @return [Native]
-    def native(level, profile)
+    def native(level, profile, opens_thought: false)
       off = level == :off
       honoured = !EFFORTS.include?(level)
       case profile&.name
       when "gemma4" then Native.new(system_token: off ? "" : GEMMA_THINK_TOKEN, prefill: off ? GEMMA_EMPTY_THOUGHT : "", honoured: honoured)
-      when "qwen36" then Native.new(system_token: "", prefill: off ? QWEN_EMPTY_THOUGHT : "", honoured: honoured)
+      when "qwen36"
+        prefill = if off then QWEN_EMPTY_THOUGHT
+                  elsif opens_thought then QWEN_OPEN_THOUGHT
+                  else ""
+                  end
+        Native.new(system_token: "", prefill: prefill, honoured: honoured)
       else Native.new(system_token: "", prefill: "", honoured: level == DEFAULT)
       end
     end

data/lib/samagotchi/thinking_notices.rb

@@ -102,16 +102,23 @@ module Samagotchi
     private
 
     # An effort on a native host, which has no knob for it: said once per
-    # session and host.
+    # session and host. A qwen36 whose server template opens a thought
+    # (Thinking.opens_thought?, from the /props answer the profile probe
+    # cached) thinks at every effort, the same.
     def announce_level(level, target)
       return if target.entry.chat?
 
       profile = @profile.call
       return if Thinking.native(level, profile).honoured
 
-      notice_once(:unsupported, target, :info,
-                  "#{level} isn't supported by native #{profile.name} on #{target.entry.name}; " \
-                  "thinking stays as the model has it")
+      text = if profile&.name == "qwen36" && Thinking.opens_thought?(target.client&.cached_server_props(model: target.bare_model))
+               "#{level} isn't supported by native #{profile.name} on #{target.entry.name}; " \
+                 "it thinks, with no effort control (low, medium and high think the same)"
+             else
+               "#{level} isn't supported by native #{profile.name} on #{target.entry.name}; " \
+                 "thinking stays as the model has it"
+             end
+      notice_once(:unsupported, target, :info, text)
     rescue StandardError => e
       failed(:announce_level, e)
     end

data/lib/samagotchi/update_command.rb

@@ -203,7 +203,7 @@ module Samagotchi
       row = Row.new(component: update.name, from: update.from, to: update.to)
       case update.status
       when :would_update, :updated
-        notes = [adds(update.adds), kept(update.kept, update.name), replaced(update.replaced)].compact
+        notes = [adds(update.adds), kept(update.kept, update.name), replaced(update.replaced), *update.kept_own].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
       when :up_to_date then up_to_date(row)
       when :skipped then skipped(row, update.note)

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.93.0"
+  VERSION = "0.95.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/vision_support.rb

@@ -61,9 +61,6 @@ module Samagotchi
 
     def self.native(target, _entry, profile, trust_config:)
       client = target.client
-      transport = client.transport.name
-      return no("#{transport} hosts take no images (only llama.cpp does)") unless transport == :llama_cpp
-
       props = client.server_props(model: target.bare_model)
       return no("can't reach /props for the media marker") unless props&.answered?