samagotchi 0.11.0 → 0.13.0

data/lib/samagotchi/tools/delegate_wait.rb

@@ -2,6 +2,7 @@
 
 require_relative "../session"
 require_relative "../reply_wait"
+require_relative "../parent_report"
 require_relative "output_guardrails"
 require_relative "peers"
 
@@ -18,6 +19,10 @@ module Samagotchi
     module DelegateWait
       TIMEOUT_DEFAULT = 600
       POLL_INTERVAL = 0.5
+      # Seconds with no worker before the child counts as gone: as long as
+      # Delegate gives a starting child (its worker takes the owner lock
+      # only once it has booted).
+      OWNER_GRACE = 15
       # Cut like an execute result: full up to TRUNCATE_AT bytes, else a
       # head-and-tail preview of PREVIEW bytes.
       TRUNCATE_AT_BYTES = OutputGuardrails::DEFAULT_TRUNCATE_AT_BYTES
@@ -39,13 +44,16 @@ module Samagotchi
       # @param peers [Peers] the parent (session_id, state_dir, cancelled?)
       # @param timeout [Integer] seconds
       # @param poll_interval [Float]
+      # @param owner_grace [Numeric] seconds with no live worker before
+      #   the child's worker counts as gone
       # @return [String] the tool result
-      def call(child_id, peers:, timeout: TIMEOUT_DEFAULT, poll_interval: POLL_INTERVAL)
+      def call(child_id, peers:, timeout: TIMEOUT_DEFAULT, poll_interval: POLL_INTERVAL, owner_grace: OWNER_GRACE)
         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])
+                                        poll_interval: poll_interval, cancelled: cancelled, baseline: baselines[key],
+                                        owner_grace: owner_grace)
         # The turn sent to is handed over: a later wait looks for a later one.
         baselines.delete(key) if %i[done no_reply].include?(wait.status)
         case wait.status
@@ -62,6 +70,9 @@ module Samagotchi
           result(child_id, "canceled", "wait canceled; the child keeps running; delegate_result #{child_id} waits again")
         when :no_reply
           result(child_id, "no_reply", "the child's turn ended without a reply (canceled, failed or empty); its session shows what happened")
+        when :worker_gone
+          result(child_id, "worker_gone",
+                 "the child's worker is gone (it stopped or crashed); delegate with session: #{child_id} starts it again with a message")
         else
           timeout_result(child_id, timeout)
         end
@@ -98,9 +109,10 @@ module Samagotchi
                "chi --attach #{child_id} shows it.")
       end
 
+      # The whole question, as `chi send --wait` prints it (ParentReport):
+      # its text, options and the commands that answer it.
       def waiting_text(child_id, pending)
-        what = pending[:kind].to_s == "approval" ? "an approval" : "a question"
-        "Child #{child_id} is waiting for an answer (#{what}); attach with chi --attach #{child_id} or answer it in the web. " \
+        "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id)}" \
           "delegate_result #{child_id} waits again once it is answered."
       end
 

data/lib/samagotchi/tools/execute.rb

@@ -25,7 +25,8 @@ module Samagotchi
 
       # @param cancelled [#call] true once the user stopped the turn: the
       #   command is killed (or not started) and its output so far returned
-      def self.call(command, cwd: nil, cancelled: -> { false })
+      # @param env [Hash, nil] added to the command's environment
+      def self.call(command, cwd: nil, cancelled: -> { false }, env: nil)
         return NOT_RUN_ON_STOP if cancelled.call
 
         command = command.strip
@@ -33,7 +34,8 @@ module Samagotchi
         return "Error: cwd not found: #{resolved_cwd}" unless resolved_cwd
 
         timeout_sec = timeout_seconds
-        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled)
+        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled,
+                                                      env: env)
 
         stdout_block = output_block("stdout", stdout)
         stderr_block = output_block("stderr", stderr)
@@ -66,7 +68,7 @@ module Samagotchi
       end
       private_class_method :stopped_result
 
-      def self.run_command(command, timeout_sec:, cwd:, cancelled: -> { false })
+      def self.run_command(command, timeout_sec:, cwd:, cancelled: -> { false }, env: nil)
         stdout_text = ""
         stderr_text = ""
         status = nil
@@ -75,7 +77,7 @@ module Samagotchi
         started = monotonic_time
         deadline = started + timeout_sec
 
-        Open3.popen3(command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
+        Open3.popen3(env || {}, command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
           stdin.close
           stdout_reader = reader_thread_for(stdout)
           stderr_reader = reader_thread_for(stderr)
@@ -173,11 +175,9 @@ module Samagotchi
       end
       private_class_method :monotonic_time
 
+      # execute.timeout_sec (SAMAGOTCHI_EXECUTE_TIMEOUT_SEC); 0 or less = the default.
       def self.timeout_seconds
-        value = Integer(ENV["SAMAGOTCHI_EXECUTE_TIMEOUT_SEC"].to_s, exception: false)
-        return TIMEOUT_SEC if value.nil? || value <= 0
-
-        value
+        OutputGuardrails.config_positive_int("execute.timeout_sec", TIMEOUT_SEC)
       end
       private_class_method :timeout_seconds
 

data/lib/samagotchi/tools/task_create.rb

@@ -9,8 +9,9 @@ module Samagotchi
 
       def self.name = NAME
 
-      def self.call(command, cwd: nil, env: nil)
-        record, error = TaskRuntime.create_task(command, cwd: cwd, env: env)
+      # @param marker_env [Hash] set after the model's env (Builtins.parent_env)
+      def self.call(command, cwd: nil, env: nil, marker_env: {})
+        record, error = TaskRuntime.create_task(command, cwd: cwd, env: env, marker_env: marker_env)
         return error if error
 
         [

data/lib/samagotchi/tools/task_runtime.rb

@@ -19,10 +19,13 @@ module Samagotchi
       METADATA_VERSION = 1
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
+      # Set by chi (Builtins.parent_env); the model's env can't change it.
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION].freeze
 
       module_function
 
-      def create_task(command, cwd: nil, env: nil)
+      # @param marker_env [Hash] chi's own variables, set over the model's +env+
+      def create_task(command, cwd: nil, env: nil, marker_env: {})
         normalized_command = command.to_s.strip
         return [nil, "Error: command is required"] if normalized_command.empty?
 
@@ -32,6 +35,8 @@ module Samagotchi
         spawn_env, env_error = spawn_env_for(env)
         return [nil, env_error] if env_error
 
+        spawn_env = spawn_env.merge(marker_env || {})
+
         task_id = generate_task_id
         task_dir = task_dir_for(task_id)
         output_path = File.join(task_dir, OUTPUT_FILENAME)
@@ -258,7 +263,7 @@ module Samagotchi
         overrides.each do |key, value|
           return [nil, "Error: env keys and values must be strings"] unless key.is_a?(String) && value.is_a?(String)
           return [nil, "Error: env keys and values cannot contain NUL bytes"] if key.include?("\0") || value.include?("\0")
-          return [nil, "Error: env key is reserved: #{key}"] if SANITIZED_ENV_KEYS.include?(key)
+          return [nil, "Error: env key is reserved: #{key}"] if SANITIZED_ENV_KEYS.include?(key) || MARKER_ENV_KEYS.include?(key)
 
           normalized[key] = value
         end

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.13.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
@@ -548,11 +539,12 @@ module Samagotchi
         last_event_seq = snapshot ? snapshot["event_seq"] : bridge_event_seq(id)
         current_turn = turn_snapshot && turn_snapshot["current_turn"]
         owner = session_owner(id)
-        # The file's question only with a live owner: one a dead worker
-        # saved can't be answered (its turn is gone).
+        # The file's question only while a worker owns the session: one a
+        # dead worker saved can't be answered (its turn is gone), nor a chi
+        # REPL's (it shares nothing with the web).
         pending = if turn_snapshot
                     current_turn && current_turn["pending_question"]
-                  elsif owner && session.respond_to?(:pending_question)
+                  elsif owner&.worker?
                     session.pending_question
                   end
         # A /model in the worker changes it before the file catches up.
@@ -581,7 +573,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 +669,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 +844,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 +1115,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/message_parts.rb

@@ -46,7 +46,8 @@ module Samagotchi
 
       QWEN_THINK = %r{<think>(.*?)</think>}m
       QWEN_OPEN_THINK = %r{\A(.*?)</think>}m # the template opened the block
-      GEMMA_THOUGHT = /<\|channel>thought(.*?)(?:<channel\|>|\z)/m
+      GEMMA_THOUGHT = Regexp.new("#{Regexp.escape(ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN)}(.*?)" \
+                                 "(?:#{Regexp.escape(ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE)}|\\z)", Regexp::MULTILINE)
 
       CallRef = Struct.new(:name, :arguments)
 

data/lib/samagotchi/web/server.rb

@@ -16,6 +16,7 @@ require_relative "../config"
 require_relative "../project_scope"
 require_relative "../log"
 require_relative "../version"
+require_relative "../cli/exit"
 
 module Samagotchi
   module Web
@@ -99,7 +100,7 @@ module Samagotchi
         # Ctrl-C: the server has stopped (start's ensure); one line, and the
         # status a shell gives a command it interrupted.
         puts "#{"\n" if $stdout.tty?}Chi Web stopped."
-        130
+        CLI::Exit::INTERRUPTED
       end
 
       # @param hub [SessionHub, nil] the session projection the page streams

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.
@@ -61,22 +61,14 @@ module Samagotchi
           bridge_up: up,
           # For the tab's notifications (notify.js): an open question, the
           # running turn's open card with actions, and how the last turn
-          # ended. A question saved by a worker that died is not open.
-          pending_question: owner ? pending_question_for(session) : nil,
+          # ended. A question saved by a worker that died is not open, nor a
+          # chi REPL's (SessionManager.worker_live?'s rule: only a worker shares it).
+          pending_question: session.waiting_question(live: !!owner&.worker?),
           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
-        return nil unless pending.is_a?(Hash) && pending[:id]
-
-        { id: pending[:id], kind: pending[:kind].to_s == "approval" ? "approval" : "question" }
-      end
-
       # status is turn state (idle/running). The live worker's snapshot is the
       # truth; on disk, a "running" with no live owner was left by a worker
       # that died mid-turn.

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