samagotchi 0.11.0 → 0.12.0

data/lib/samagotchi/terminal_ui.rb

@@ -12,7 +12,6 @@ require_relative "context_note"
 require_relative "cancellation_controller"
 require_relative "llm/errors"
 require_relative "host_registry"
-require_relative "kernel_loop"
 require_relative "session"
 require_relative "owner_lock"
 require_relative "engine"
@@ -114,9 +113,6 @@ module Samagotchi
       # The model it starts on names a configured host (a bad default.model
       # doesn't matter when --model or the session picks another).
       ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
-      # Only a caller's profile goes in; otherwise the Engine resolves one
-      # for the effective model and hands it to the kernel.
-      @kernel         = KernelLoop.new(client: @client, profile: profile, reminder_store: Samagotchi::ReminderStore.new)
       @no_default_input = no_default_input
       @non_interactive = non_interactive
       # --memory and --mute, with a resumed session's own lists first: a
@@ -157,7 +153,6 @@ module Samagotchi
         model_name: nil,
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
-        kernel: @kernel,
         recap: scratch ? nil : recap_config,
         scratch: scratch,
         reminders: {
@@ -245,7 +240,9 @@ module Samagotchi
           cancel_controller: nil,
           images: ImageInput.extract(@prompt)
         )
-        if empty_answer?(result)
+        # No answer (the empty-answer retries used up): no text, or the chat
+        # loop's placeholder (LLM::ModelResult#empty_answer?).
+        if result.empty_answer?
           # Nothing to print: say so on stderr and fail, so a script that
           # pipes the answer doesn't take the silence for one.
           session.save
@@ -281,15 +278,6 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
-    # A -p --non-interactive turn that ended with no answer (the empty-answer
-    # retries used up): no text, or the chat loop's placeholder.
-    def empty_answer?(result)
-      return false if result.respond_to?(:canceled?) && result.canceled?
-      return false if result.respond_to?(:resumable?) && result.resumable?
-
-      result.output.to_s.strip.empty? || (result.respond_to?(:empty_answer?) && result.empty_answer?)
-    end
-
     # Delete the scratch session, the last thing the REPL does. Quiet after
     # a one-shot or on the way out of an error or a signal.
     def delete_scratch(session, quiet:)
@@ -669,7 +657,7 @@ module Samagotchi
     # After a prompt or continue turn: TurnFlow keeps the checkpoint and the
     # continue offer; the REPL saves and tells the user.
     def finish_turn(session, result, continue:)
-      if result.respond_to?(:canceled?) && result.canceled?
+      if result.canceled?
         outcome = @turn_flow.after_turn(result, continue: continue)
         # A cancelled continue is back where it started, the offer still open.
         return if outcome == :continue_cancelled
@@ -680,7 +668,7 @@ module Samagotchi
         # user's next message continues from it. !rollback restores the
         # pre-turn checkpoint for an explicit full discard (the renderer's
         # hint under :turn_canceled says so).
-        save_session(session) if result.respond_to?(:conversation) && result.conversation.is_a?(Array)
+        save_session(session) if result.conversation.is_a?(Array)
         return
       end
 
@@ -758,9 +746,9 @@ module Samagotchi
       ensure
         @surface.clear_slot(:hints)
       end
-      canceled = result.respond_to?(:canceled?) && result.canceled?
+      canceled = result&.canceled?
       if result && !canceled
-        session.messages = result.conversation if result.respond_to?(:conversation) && result.conversation.is_a?(Array)
+        session.messages = result.conversation if result.conversation.is_a?(Array)
         @engine.store_model!(session)
         session.save
       end
@@ -996,15 +984,7 @@ module Samagotchi
     end
 
     def cancelled_result_from(messages, reason:)
-      KernelLoop::Result.new(
-        output: "",
-        conversation: clone_messages(messages),
-        exhausted: false,
-        pending_tool_calls: false,
-        tool_activity: [],
-        canceled: true,
-        cancellation_reason: reason
-      )
+      LLM::ModelResult.new(text: "", conversation: clone_messages(messages), canceled: true, cancellation_reason: reason)
     end
 
     # The status row under the prompt, from the Engine's state (what a

data/lib/samagotchi/thinking.rb

@@ -65,7 +65,7 @@ module Samagotchi
       key, value = ConfigFile.model_setting(names, :thinking, models: models)
       return [value, "models: #{key}"] if key
 
-      host = target.entry.respond_to?(:thinking) ? target.entry.thinking : nil
+      host = target.entry.thinking
       return [host, "hosts.#{target.entry.name}"] if host
       return [global, "thinking.level"] if global
 

data/lib/samagotchi/tool_runner.rb

@@ -146,7 +146,7 @@ module Samagotchi
     # says the image is attached, that line replaces the text.
     # @return [Array(Hash, Array<Hash>)] the result and its refs
     def attach_images(call, result)
-      vision = @kernel.vision if @kernel.respond_to?(:vision)
+      vision = @kernel.turn_settings.vision
       reason = if vision.nil? then "images can't be attached here"
                elsif !vision.sendable? then ImagePlan::CANT_SEE
                end
@@ -192,7 +192,7 @@ module Samagotchi
     end
 
     # The kernel's tools, for the activity line of a tool that isn't built in.
-    def tools = @kernel.respond_to?(:tools) ? @kernel.tools : nil
+    def tools = @kernel.tools
 
     # A tool the registry has from a plugin (not core, not unknown).
     def plugin_tool?(name)
@@ -206,8 +206,7 @@ module Samagotchi
     # The Engine sets the kernel's gate (its context, later the approval
     # flow); a bare kernel (specs) gets one that only runs the hooks.
     def gate
-      given = @kernel.guardrail_gate if @kernel.respond_to?(:guardrail_gate)
-      given || (@gate ||= Guardrails::Gate.new(-> { @kernel.hooks if @kernel.respond_to?(:hooks) }, tools_lookup: -> { tools }))
+      @kernel.guardrail_gate || (@gate ||= Guardrails::Gate.new(-> { @kernel.hooks }, tools_lookup: -> { tools }))
     end
 
     # A gate that fails denies the call (fail closed).
@@ -254,8 +253,7 @@ module Samagotchi
 
     # A failing hook must not break the turn.
     def fire(name, event)
-      hooks = @kernel.hooks if @kernel.respond_to?(:hooks)
-      hooks&.fire(name, event)
+      @kernel.hooks&.fire(name, event)
     rescue StandardError
       nil
     end

data/lib/samagotchi/tools/builtins.rb

@@ -103,7 +103,7 @@ module Samagotchi
       # (as DelegateWait does); a bare kernel has no peers: never cancelled.
       def cancelled_proc(kctx)
         peers = kctx.peers
-        -> { peers.respond_to?(:cancelled?) && peers.cancelled? }
+        -> { !!peers&.cancelled? }
       end
 
       # @return [Registry] a new registry with the built-ins, in

data/lib/samagotchi/tools/delegate_wait.rb

@@ -43,7 +43,7 @@ module Samagotchi
       def call(child_id, peers:, timeout: TIMEOUT_DEFAULT, poll_interval: POLL_INTERVAL)
         sd = peers.state_dir || Session.default_state_dir
         key = [peers.session_id, child_id]
-        cancelled = -> { peers.respond_to?(:cancelled?) && peers.cancelled? }
+        cancelled = -> { peers.cancelled? }
         wait = ReplyWait.call(child_id, state_dir: sd, cursor: seen[key], timeout: timeout.to_i,
                                         poll_interval: poll_interval, cancelled: cancelled, baseline: baselines[key])
         # The turn sent to is handed over: a later wait looks for a later one.

data/lib/samagotchi/turn_flow.rb

@@ -72,7 +72,7 @@ module Samagotchi
     #   turn: its partial progress stays, !rollback can undo it) or
     #   :continue_cancelled (back to before the continue; the offer stays)
     def after_turn(result, continue: false, no_interrupt: false)
-      if result.respond_to?(:canceled?) && result.canceled?
+      if result.canceled?
         if continue
           restore(@continue_checkpoint)
           return :continue_cancelled
@@ -85,7 +85,7 @@ module Samagotchi
         return :cancelled
       end
 
-      if result.respond_to?(:resumable?) && result.resumable?
+      if result.resumable?
         @offer = { context: interrupted_turn_context(result), no_interrupt: no_interrupt }
         :continue_offered
       else
@@ -172,7 +172,7 @@ module Samagotchi
     end
 
     def conversation_of(result)
-      result.conversation if result.respond_to?(:conversation) && result.conversation.is_a?(Array)
+      result.conversation if result.conversation.is_a?(Array)
     end
 
     def interrupted_turn_context(result)
@@ -198,7 +198,7 @@ module Samagotchi
     end
 
     def tool_trace(result)
-      activities = result.respond_to?(:tool_activity) ? Array(result.tool_activity) : []
+      activities = Array(result.tool_activity)
       activities.last(SUMMARY_TOOLS_LIMIT).map do |activity|
         tool = activity[:tool].to_s.strip
         status = activity[:status].to_s.strip

data/lib/samagotchi/turn_state.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Samagotchi
+  # A session's turn as other threads see it: whether one runs, its cancel
+  # controller and event sink, the plugin steers waiting for its next
+  # boundary, and the activity clock the idle jobs read.
+  #
+  # The turn thread writes it (Engine#begin_turn, #release_turn); the idle
+  # scheduler, the bridge's request threads, plugin threads and the UIs
+  # read it. The lock is a leaf: nothing is called out while it is held,
+  # so any lock may be held around a call into it, and it is never held
+  # around anything else.
+  class TurnState
+    # @param clock [#call] monotonic seconds
+    def initialize(clock:)
+      @clock = clock
+      @lock = Monitor.new
+      @last_activity_at = clock.call
+      @activity_seq = 0
+      @running = false
+      @controller = nil
+      @sink = nil
+      @steers = []
+    end
+
+    # ── Activity clock ──────────────────────────────────────────────────
+
+    # Activity happened (user input, a finished turn): the clock moves to
+    # +now+ and the sequence advances, so the idle jobs re-arm.
+    # @param now [Float, nil] monotonic seconds; the clock's now by default
+    def record_activity(now = nil)
+      now = now ? now.to_f : @clock.call
+      @lock.synchronize do
+        @last_activity_at = now
+        @activity_seq += 1
+      end
+    end
+
+    # Start the idle window now without counting it as activity (the
+    # sequence stays): the Engine does once its plugins have loaded, so a
+    # slow plugin start doesn't shorten the first window.
+    def restart_clock!
+      now = @clock.call
+      @lock.synchronize { @last_activity_at = now }
+    end
+
+    # @return [Float] monotonic seconds of the last activity
+    def last_activity_at
+      @lock.synchronize { @last_activity_at }
+    end
+
+    # @return [Integer] how many times activity was recorded
+    def activity_seq
+      @lock.synchronize { @activity_seq }
+    end
+
+    # ── The turn ────────────────────────────────────────────────────────
+
+    # @return [Boolean] whether a turn runs
+    def running?
+      @lock.synchronize { @running }
+    end
+
+    # A turn begins: running, with its controller and sink, in one step.
+    def begin!(controller:, sink:)
+      @lock.synchronize do
+        @running = true
+        @controller = controller
+        @sink = sink
+      end
+    end
+
+    # The turn is over: not running, no controller, sink or steers.
+    # @return [Array<Hash>] the steers it never took ({text:, source:})
+    def finish!
+      @lock.synchronize do
+        @running = false
+        @controller = nil
+        @sink = nil
+        @steers.tap { @steers = [] }
+      end
+    end
+
+    # @return [CancellationController, nil] the running turn's controller
+    def controller
+      @lock.synchronize { @controller }
+    end
+
+    # Cancel the running turn, if any (outside the lock).
+    # @return [Boolean] whether a cancellation was triggered
+    def cancel!(reason)
+      ctrl = controller
+      return false unless ctrl
+
+      ctrl.cancel!(reason)
+    end
+
+    # @return [Array(Boolean, #call)] whether a turn runs, and its sink
+    def in_turn_sink
+      @lock.synchronize { [@running, @sink] }
+    end
+
+    # ── Steers ──────────────────────────────────────────────────────────
+
+    # Queue +text+ for the running turn's next boundary.
+    # @return [Boolean] whether it was queued (false: blank, or no turn)
+    def steer(text, source:)
+      text = text.to_s.strip
+      return false if text.empty?
+
+      @lock.synchronize do
+        return false unless @running
+
+        @steers << { text: text, source: source.to_s }
+      end
+      true
+    end
+
+    # @return [Array<Hash>] the steers queued so far ({text:, source:}), taken
+    def take_steers
+      @lock.synchronize { @steers.tap { @steers = [] } }
+    end
+  end
+end

data/lib/samagotchi/used_memories.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+require_relative "muted_memories"
+require_relative "tools/memory"
+require_relative "tools/read"
+
+module Samagotchi
+  # The memories a session used: the ones its turns read (memory_read, or a
+  # read of a memories/*.md file) or preloaded. Deduped, in first-use
+  # order. Written by the turn thread (and the main thread setting the
+  # session), read by any (the bridge's snapshot, the UIs).
+  class UsedMemories
+    # The memory names a tool call reads, or nil when it reads none.
+    # @param call [Hash] {name:, content:}
+    # @return [Array<String>, String, nil]
+    def self.names_from_call(call)
+      return nil unless call.is_a?(Hash)
+
+      content = call[:content].to_s.strip
+      return nil if content.empty?
+
+      case call[:name].to_s
+      when Tools::MemoryRead::NAME
+        Tools::MemoryRead.parse_names(content).filter_map { |name| normalize(name) }
+      when Tools::Read::NAME
+        path = content.tr("\\", "/")
+        path.match?(%r{memories/.+\.md\z}) ? normalize(path) : nil
+      end
+    end
+
+    # A memory's name as the list keeps it: the basename without .md.
+    def self.normalize(raw)
+      value = raw.to_s.strip
+      return nil if value.empty?
+
+      base = File.basename(value, ".md").strip
+      base.empty? ? nil : base
+    end
+    private_class_method :normalize
+
+    # @param names [Array<String>] the names already used (a resumed session's)
+    def initialize(names = [])
+      @lock = Monitor.new
+      @names = []
+      add(names)
+    end
+
+    # @return [Array<String>] a copy of the list
+    def names
+      @lock.synchronize { @names.dup }
+    end
+
+    # Add names, skipping blanks and ones already there.
+    def add(names)
+      @lock.synchronize do
+        Array(names).each do |name|
+          value = name.to_s.strip
+          @names << value unless value.empty? || @names.include?(value)
+        end
+      end
+      self
+    end
+
+    # Add the names a session already used.
+    def absorb(session)
+      return self unless session
+
+      add(Array(session.used_memory_names))
+    end
+
+    # A memory read as it starts (:tool_call_started): its names join the
+    # list. A refused read of a muted memory is not a use of it.
+    # @param muted [Array<String>] the session's muted names (normalized)
+    # @return [Array<String>, nil] the names this call read, nil for any other event
+    def capture(event, muted:)
+      return nil unless event.is_a?(Hash) && event[:type] == :tool_call_started
+
+      call = event[:call].is_a?(Hash) ? event[:call] : {}
+      names = Array(self.class.names_from_call(call)).reject { |name| MutedMemories.muted?(name, muted) }
+      return nil if names.empty?
+
+      add(names)
+      names
+    end
+  end
+end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -60,10 +60,10 @@ module Samagotchi
 
     def self.native(target, entry, profile, trust_config:)
       client = target.client
-      transport = client.respond_to?(:transport) ? client.transport.name : :llama_cpp
+      transport = client.transport.name
       return no("#{transport} hosts take no images (only llama.cpp does)") unless transport == :llama_cpp
 
-      props = client.respond_to?(:server_props) ? client.server_props(model: target.bare_model) : nil
+      props = client.server_props(model: target.bare_model)
       return no("can't reach /props for the media marker") unless props&.answered?
 
       body = props.body.is_a?(Hash) ? props.body : {}
@@ -83,14 +83,14 @@ module Samagotchi
 
     def self.chat(target, entry, adapter)
       unless entry.remote?
-        props = entry.client.respond_to?(:server_props) ? entry.client.server_props(model: target.bare_model) : nil
+        props = entry.client.server_props(model: target.bare_model)
         if props&.answered? && props.body.is_a?(Hash) && props.body.key?("modalities")
           vision = props.body.dig("modalities", "vision") == true
           return vision ? Answer.new(value: true, reason: nil) : no("the server has no vision model loaded (start llama.cpp with --mmproj)")
         end
       end
 
-      listed = adapter.respond_to?(:image_input) ? adapter.image_input(model: target.bare_model) : nil
+      listed = adapter&.image_input(model: target.bare_model)
       return Answer.new(value: true, reason: nil) if listed == true
       return no("host #{entry.name} lists #{target.bare_model} as text-only") if listed == false
 

data/lib/samagotchi/web/app.rb

@@ -16,6 +16,7 @@ require_relative "../session_manager"
 require_relative "../session_commands"
 require_relative "../steer"
 require_relative "../host_registry"
+require_relative "../model_catalog"
 require_relative "../model_profile"
 require_relative "../project_scope"
 require_relative "../prompt_history"
@@ -335,12 +336,10 @@ module Samagotchi
 
         root = dir && ProjectScope.root_for(dir)
         # Lazy retention sweep (once per 24h)
-        if @manager.respond_to?(:retention_sweep_if_due)
-          begin
-            @manager.retention_sweep_if_due(state_dir: @state_dir)
-          rescue StandardError
-            nil
-          end
+        begin
+          @manager.retention_sweep_if_due(state_dir: @state_dir)
+        rescue StandardError
+          nil
         end
         limit = sanitize_limit(req.params["limit"])
         offset = sanitize_offset(req.params["offset"])
@@ -417,19 +416,11 @@ module Samagotchi
             warnings << "the hosts are still listing their models"
           else
             default_host = registry.default_entry&.name
-            ordered = results.keys.sort_by { |name| [name == default_host ? 0 : 1, name] }
-            ordered.each do |host|
-              data = results[host]
-              if data[:error]
-                warnings << "#{host}: #{data[:error]}"
-                next
-              end
-              Array(data[:models]).each do |info|
-                id = info.id.to_s
-                next if id.strip.empty? || id.end_with?(":batch")
-
-                models << { name: host == default_host ? id : "#{host}:#{id}", host: host, id: id }
-              end
+            listing = ModelCatalog.listing(results, registry: registry)
+            warnings.concat(listing.warnings)
+            # the web's own spelling, kept as it was: bare on the default host
+            listing.rows.each do |row|
+              models << { name: row.host == default_host ? row.id : "#{row.host}:#{row.id}", host: row.host, id: row.id }
             end
           end
         rescue StandardError => e
@@ -552,7 +543,7 @@ module Samagotchi
         # saved can't be answered (its turn is gone).
         pending = if turn_snapshot
                     current_turn && current_turn["pending_question"]
-                  elsif owner && session.respond_to?(:pending_question)
+                  elsif owner
                     session.pending_question
                   end
         # A /model in the worker changes it before the file catches up.
@@ -581,7 +572,7 @@ module Samagotchi
           session: session_json,
           history: read_history(id),
           messages: messages_for_display(raw_messages, parts: req.params["parts"] == "1",
-                                                       cwd: session.respond_to?(:working_directory) ? session.working_directory : nil),
+                                                       cwd: session.working_directory),
           failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
           queued: turn_snapshot ? Array(turn_snapshot["queued"]) : [],
@@ -677,7 +668,7 @@ module Samagotchi
         line = body["line"].to_s.strip
         return error_response(400, "missing_fields", "line is required") if line.empty?
 
-        @manager.resume_session(id, state_dir: @state_dir) if @manager.respond_to?(:resume_session)
+        @manager.resume_session(id, state_dir: @state_dir)
         # card: a card's action; its command events say so (no echo).
         request = ->(client) { client.post_command(line: line, client_id: body["client_id"], card: body["card"] == true) }
         relay(id, live_bridge_client(id), request, what: "the command was not run", cant: "run commands") do |reply|
@@ -852,8 +843,6 @@ module Samagotchi
 
       # The process holding the session (an OwnerLock::Owner), or nil. A worker always runs a Bridge; a TUI (plain `chi`) doesn't share.
       def session_owner(id)
-        return nil unless @manager.respond_to?(:session_owner)
-
         @manager.session_owner(id, state_dir: @state_dir)
       rescue StandardError
         nil
@@ -1125,16 +1114,8 @@ module Samagotchi
         end
       end
 
-      # status is turn state (idle/running): SessionSummary.displayed_status,
-      # unless the manager can't tell who owns a session (then the file's
-      # word stands).
+      # status is turn state (idle/running): SessionSummary.displayed_status.
       def displayed_status(session, snapshot = nil, owner: session_owner(session.id))
-        unless @manager.respond_to?(:session_owner)
-          return snapshot["status"] if snapshot.is_a?(Hash) && snapshot["status"]
-
-          return session.status
-        end
-
         SessionSummary.displayed_status(session, snapshot, owner: owner)
       end
 

data/lib/samagotchi/web/session_hub.rb

@@ -197,8 +197,6 @@ module Samagotchi
       end
 
       def sweep
-        return unless @manager.respond_to?(:retention_sweep_if_due)
-
         @manager.retention_sweep_if_due(state_dir: @state_dir)
       rescue StandardError
         nil
@@ -288,8 +286,6 @@ module Samagotchi
       end
 
       def owner_of(id)
-        return nil unless @manager.respond_to?(:session_owner)
-
         @manager.session_owner(id, state_dir: @state_dir)
       rescue StandardError
         nil

data/lib/samagotchi/web/session_summary.rb

@@ -28,7 +28,7 @@ module Samagotchi
       #   looks its project up)
       # @return [Hash] symbol keys
       def build(session, owner:, session_dir:, status: displayed_status(session, owner: owner), root_cache: nil)
-        used = session.respond_to?(:used_memory_names) ? Array(session.used_memory_names) : []
+        used = Array(session.used_memory_names)
         up = bridge_up?(session_dir, owner)
         {
           id: session.id,
@@ -43,10 +43,10 @@ module Samagotchi
           test_run: !!session.test_run,
           used_memory_names: used,
           # The session's --memory and --mute lists (info-bar tooltip).
-          preloaded_memory_names: session.respond_to?(:preloaded_memory_names) ? Array(session.preloaded_memory_names) : [],
-          muted_memory_names: session.respond_to?(:muted_memory_names) ? Array(session.muted_memory_names) : [],
+          preloaded_memory_names: Array(session.preloaded_memory_names),
+          muted_memory_names: Array(session.muted_memory_names),
           # The session that delegated this one (the `delegate` tool), else nil.
-          parent_id: session.respond_to?(:parent_id) ? session.parent_id : nil,
+          parent_id: session.parent_id,
           first_preview: first_preview_for(session),
           owner: owner&.kind,
           # The saved recap's first sentence, for the session card.
@@ -64,14 +64,14 @@ module Samagotchi
           # ended. A question saved by a worker that died is not open.
           pending_question: owner ? pending_question_for(session) : nil,
           pending_card: up ? Bridge::PendingCard.read(session_dir) : nil,
-          last_turn: session.respond_to?(:last_turn) ? session.last_turn : nil
+          last_turn: session.last_turn
         }
       end
 
       # The open question as {id:, kind:} ("approval" for a guardrail's,
       # else "question"); nil when there is none. The text stays out.
       def pending_question_for(session)
-        pending = session.respond_to?(:pending_question) ? session.pending_question : nil
+        pending = session.pending_question
         return nil unless pending.is_a?(Hash) && pending[:id]
 
         { id: pending[:id], kind: pending[:kind].to_s == "approval" ? "approval" : "question" }

data/lib/samagotchi/worker.rb

@@ -475,7 +475,7 @@ module Samagotchi
         refuse_queued_commands
       end
       yield result, error
-      response = result.respond_to?(:output) ? result.output : nil
+      response = result&.output
       SessionInbox.write_output(@session_dir, response) unless response.nil? || response.strip.empty?
       save_session
     end