samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/tools/delegate.rb

@@ -10,6 +10,7 @@ require_relative "../guardrails/context"
 require_relative "peers"
 require_relative "delegate_wait"
 require_relative "../child_reports"
+require_relative "../worker_link"
 
 module Samagotchi
   # Loaded on first use: this autoload keeps SessionManager and its ~80
@@ -32,11 +33,6 @@ module Samagotchi
       # A path in a task: absolute, ~/ or ../, not glued to a word (a URL's
       # /api is not one) and stopping at quotes, backticks or punctuation.
       PATH_TOKEN = %r{(?<![\w./~-])(?:~/|\.\./|/(?!/))[^\s`'"<>()\[\]{},;&|]*}
-      # A child spawned this many seconds ago counts as running even before
-      # its worker holds the owner lock: two delegate calls in one model
-      # message come milliseconds apart, and the first child's worker is
-      # still starting when the second call counts.
-      STARTING_GRACE_SECONDS = 15
       # The memory every child starts with, scoped so a project memory of
       # the same name cannot shadow it.
       CHILD_MEMORIES = [Session::DELEGATE_MEMORY].freeze
@@ -79,7 +75,11 @@ module Samagotchi
 
         note = Array(warnings).map { |warning| "Warning: #{warning}\n" }.join
         if wait
-          result = DelegateWait.call(child_id, peers: peers, timeout: timeout)
+          started = monotonic
+          boot = await_worker(child_id, state_dir: sd, timeout: timeout, cancelled: -> { peers.cancelled? })
+          return note + DelegateWait.boot_result(child_id, boot, timeout: timeout, peers: peers) unless boot == :up
+
+          result = DelegateWait.call(child_id, peers: peers, timeout: timeout, waited: monotonic - started)
           return RefText.wrap(note + result, result.respond_to?(:ref_path) ? result.ref_path : nil)
         end
 
@@ -90,6 +90,32 @@ module Samagotchi
         "Error: #{e.message}"
       end
 
+      # Before a wait on a child this call started or woke: its worker
+      # takes the owner lock only once it has booted, so the wait's one
+      # dead-worker rule (ReplyWait::GONE_AFTER) runs from there. A child a
+      # worker (or a one-turn run) owns already goes straight on; else its
+      # worker gets WorkerLink::START_LIMIT, the boot limit, to come up,
+      # within the call's +timeout+ (its time counts against it) and
+      # until the parent's turn is canceled.
+      # @param cancelled [#call] the parent's cancel (Peers#cancelled?)
+      # @return [Symbol] :up (a worker owns it), :gone (none came up within
+      #   the boot limit), :timeout (+timeout+ ran out first) or :canceled
+      def self.await_worker(child_id, state_dir:, timeout:, cancelled: -> { false })
+        dir = Session.session_dir(child_id, state_dir: state_dir)
+        return :up if OwnerLock.owner(dir)
+
+        limit = [WorkerLink::START_LIMIT, timeout.to_f].min
+        link = WorkerLink.await(child_id, session_dir: dir, timeout: limit, unlink: false,
+                                          give_up: ->(found) { found.worker_owned? || cancelled.call })
+        return :up if link&.worker_owned?
+        return :canceled if cancelled.call
+
+        limit < WorkerLink::START_LIMIT ? :timeout : :gone
+      end
+
+      def self.monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      private_class_method :monotonic
+
       # How the reply of a child left running comes back: a report only
       # reaches a parent that can get one (DelegateWait.reports_mode).
       def self.running_hint(peers)
@@ -135,7 +161,7 @@ module Samagotchi
         running = running_children(parent.id, state_dir: state_dir)
         max = max_children
         if running.size >= max
-          ids = running.map { |s| s[:short_id] }.join(", ")
+          ids = running.map(&:short_id).join(", ")
           return "Error: #{running.size} delegate#{"s" if running.size != 1} of this session #{running.size == 1 ? "is" : "are"} running " \
                  "(the most is #{max}, #{MAX_CHILDREN_KEY}): #{ids}. #{full_hint(peers)}"
         end
@@ -255,9 +281,10 @@ module Samagotchi
       private_class_method :unknown_toolkit
 
       # The new child's folder: the parent's, or +cwd+ (relative to the
-      # parent's) when it is a folder of the parent's repository, in any of
-      # its worktrees (one project_root, from the common git dir). Outside
-      # git only a subfolder of the parent's folder. Nothing is created
+      # parent's) when it is a folder of the parent's project: in any of its
+      # repository's worktrees (one project_root, from the common git dir), or
+      # in its marked folder. Outside both only a subfolder of the parent's
+      # folder. Nothing is created
       # here: the model makes a worktree with execute, where guardrails see it.
       # @return [String] an absolute folder, or an Error: line
       def self.child_cwd(cwd, parent)
@@ -268,8 +295,8 @@ module Samagotchi
         return "Error: cwd #{folder} is not a folder (create the worktree first)" unless File.directory?(folder)
 
         folder = File.realpath(folder)
-        unless same_repository?(folder, base)
-          return "Error: cwd must be a folder of this session's repository (a worktree or subfolder of it), not #{folder}"
+        unless same_project?(folder, base)
+          return "Error: cwd must be a folder of this session's project (a worktree or subfolder of it), not #{folder}"
         end
         if MemoryPaths.in_repo?(base) && !work_tree?(folder)
           return "Error: cwd #{folder} is not in a work tree of this session's repository (a git dir, or a bare " \
@@ -301,8 +328,11 @@ module Samagotchi
       def self.within?(path, dir) = path == dir || path.start_with?("#{dir}/")
       private_class_method :within?
 
-      def self.same_repository?(folder, base)
-        if MemoryPaths.in_repo?(base)
+      # One project (a git repository or a marked folder): the same project
+      # root, so a nested repository or marked project is another one. A base
+      # in no project: a subfolder of it.
+      def self.same_project?(folder, base)
+        if MemoryPaths.in_project?(base)
           MemoryPaths.project_root(folder) == MemoryPaths.project_root(base)
         else
           within?(folder, File.realpath(base))
@@ -310,7 +340,7 @@ module Samagotchi
       rescue SystemCallError
         false
       end
-      private_class_method :same_repository?
+      private_class_method :same_project?
 
       # @return [String] the child's id, or an Error: line
       def self.follow_up(task, session:, parent:, state_dir:)
@@ -349,28 +379,17 @@ module Samagotchi
       end
       private_class_method :follow_up
 
-      # The child's turn a delivered follow-up joins, for the wait
-      # (DelegateCursor#turn): the running turn's (its checkpoint mark), the
-      # follow-up merging into it; else the delivery's +enqueued_id+, the
-      # follow-up running as a turn of its own. Only
-      # from a worker that names turn_ids; nil otherwise, or when the
-      # running turn has no id (a delegate's first turn): the wait takes the
-      # next reply.
-      # A follow-up steered into a turn that ended before it merged runs as
-      # its own turn, yet the wait is on the ended one (LOW, as before).
-      # One the child's idle look missed being merged into a turn starting
-      # then never runs as its own: ReplyWait falls back to that turn's
-      # reply (merged_elsewhere?).
+      # The child's turn a delivered follow-up's wait is bound to
+      # (DelegateCursor#turn): its own, the delivery's +enqueued_id+,
+      # whether it runs as a turn of its own (the child idle, or its
+      # running turn ended before taking it) or a running turn's drain
+      # merges it (that turn's end is its answer: the drain's merge record,
+      # or ReplyWait's inference for a 0.156 child, ReplyWait::Poll#
+      # follow_merge). Only from a worker that names turn_ids; nil
+      # otherwise: the wait takes the next reply.
       # @return [String, nil]
       def self.follow_up_turn(id, enqueued_id, state_dir:)
-        return nil unless ReplyWait.turn_ids?(Session.session_dir(id, state_dir: state_dir))
-
-        child = Session.load(id, state_dir: state_dir)
-        return child.interrupted_turn&.enqueued_id if child.status == Session::STATUS_RUNNING
-
-        enqueued_id
-      rescue ArgumentError
-        nil
+        ReplyWait.turn_ids?(Session.session_dir(id, state_dir: state_dir)) ? enqueued_id : nil
       end
       private_class_method :follow_up_turn
 
@@ -388,23 +407,13 @@ module Samagotchi
 
       # The children of +parent_id+ that count against session.max_children
       # (a plugin's ctx.sessions.fork counts them too).
-      # @return [Array<Hash>] SessionManager.children_of rows
+      # A child spawned moments ago counts as running even before its worker
+      # holds the owner lock (SessionRow#running_or_starting?): two delegate
+      # calls in one model message come milliseconds apart, and the first
+      # child's worker is still starting when the second call counts.
+      # @return [Array<SessionRow>] SessionManager.children_of rows
       def self.running_children(parent_id, state_dir:)
-        SessionManager.children_of(parent_id, state_dir: state_dir).select { |s| running?(s) }
-      end
-
-      # busy (a worker runs its turn), or running with a worker on its way
-      # (ChildrenStatus asks it too).
-      # @param summary [Hash] a children_of row, or the same keys: busy,
-      #   saved_status (the file's: the displayed status shows a worker on
-      #   its way as idle), live, updated_at
-      def self.running?(summary)
-        return true if summary[:busy]
-        return false unless summary[:saved_status] == Session::STATUS_RUNNING && !summary[:live]
-
-        Time.now - Time.iso8601(summary[:updated_at].to_s) < STARTING_GRACE_SECONDS
-      rescue ArgumentError
-        false
+        SessionManager.children_of(parent_id, state_dir: state_dir).select(&:running_or_starting?)
       end
 
       def self.max_children

data/lib/samagotchi/tools/delegate_relay.rb

@@ -262,16 +262,16 @@ module Samagotchi
         #   oldest question first
         def waiting
           rows = SessionManager.children_of(@parent_id, state_dir: @state_dir).select do |row|
-            row[:id] != @except && KINDS.include?(row[:waiting].to_s) && !@done[row[:waiting_id].to_s]
+            row.id != @except && KINDS.include?(row.waiting.to_s) && !@done[row.waiting_id.to_s]
           end
           rows.filter_map do |row|
-            child = Session.load(row[:id], state_dir: @state_dir)
+            child = Session.load(row.id, state_dir: @state_dir)
             pending = child.pending_question
-            next nil unless pending && pending.id.to_s == row[:waiting_id].to_s
+            next nil unless pending && pending.id.to_s == row.waiting_id.to_s
             next nil unless DelegateRelay.relayable?(@relay, pending, strategy: Guardrails::ParentPolicy.for_session(child),
-                                                                      child_id: row[:id])
+                                                                      child_id: row.id)
 
-            [row[:id], pending]
+            [row.id, pending]
           rescue ArgumentError
             nil
           end.sort_by { |_, pending| pending.created_at.to_s }

data/lib/samagotchi/tools/delegate_result.rb

@@ -45,7 +45,7 @@ module Samagotchi
       end
 
       def self.newest_running_child(parent_id, state_dir:)
-        SessionManager.children_of(parent_id, state_dir: state_dir).find { |s| s[:busy] }&.fetch(:id)
+        SessionManager.children_of(parent_id, state_dir: state_dir).find(&:busy)&.id
       end
       private_class_method :newest_running_child
     end

data/lib/samagotchi/tools/delegate_wait.rb

@@ -8,6 +8,7 @@ require_relative "peers"
 require_relative "delegate_relay"
 require_relative "delegate_cursor"
 require_relative "ref_text"
+require_relative "../worker_link"
 
 module Samagotchi
   # Loaded on first use: child_reports requires this file (a circular
@@ -27,10 +28,6 @@ module Samagotchi
       Advance = Data.define(:cursor, :already_reported)
       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
@@ -50,7 +47,9 @@ module Samagotchi
       # @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
+      #   the child's worker counts as gone (ReplyWait::GONE_AFTER; a child
+      #   whose worker is on its way was awaited first:
+      #   Delegate.await_worker)
       # @return [String] the tool result
       #
       # A child's approval, when this session can host a relay (Peers#relay),
@@ -59,7 +58,10 @@ module Samagotchi
       # against +timeout+, and the result gets one outcome line per relayed
       # approval. Without a relay, and for the model's and hooks' questions,
       # the question comes back to the model as before.
-      def call(child_id, peers:, timeout: TIMEOUT_DEFAULT, poll_interval: POLL_INTERVAL, owner_grace: OWNER_GRACE)
+      # @param waited [Numeric] seconds of +timeout+ already spent before
+      #   this wait (Delegate's boot await); the result still names +timeout+
+      def call(child_id, peers:, timeout: TIMEOUT_DEFAULT, poll_interval: POLL_INTERVAL, owner_grace: ReplyWait::GONE_AFTER,
+               waited: 0)
         sd = peers.state_dir || Session.default_state_dir
         key = [peers.session_id, child_id]
         cancelled = -> { peers.cancelled? }
@@ -73,15 +75,15 @@ module Samagotchi
           cursor = report_claim.cursor.with(report_claim: report_claim)
         end
 
-        baseline = cursor.baseline
-        left = timeout.to_i
+        target = ReplyWait::Target.from_cursor(cursor, child: Session.summary_from_file(Session.session_file(child_id, state_dir: sd)),
+                                                       owner_grace: owner_grace)
+        left = timeout.to_i - waited
         outcomes = relayed_outcomes.delete(key) || []
         loop do
           started = monotonic
-          wait = ReplyWait.call(child_id, state_dir: sd, cursor: cursor.reply_file, timeout: [left, 0].max,
-                                          poll_interval: poll_interval, cancelled: cancelled, baseline: baseline,
-                                          owner_grace: owner_grace, interject: others && -> { others.poll },
-                                          turn: cursor.turn, message_waiting: message_waiting)
+          wait = ReplyWait.call(child_id, state_dir: sd, **target.to_h, timeout: [left, 0].max,
+                                          poll_interval: poll_interval, cancelled: cancelled,
+                                          interject: others && -> { others.poll }, message_waiting: message_waiting)
           left -= monotonic - started
           unless wait.status == :waiting_for_answer &&
                  DelegateRelay.relayable?(relay, wait.question, strategy: Guardrails::ParentPolicy.for_session(wait.session),
@@ -108,7 +110,7 @@ module Samagotchi
           # asked), the relayed question no longer reported: a turn that
           # ends with no reply during the relay's POST or after it still
           # ends the wait.
-          baseline = ReplyWait.baseline_of(wait.session, question_id: wait.question.id)
+          target = target.with(baseline: ReplyWait.baseline_of(wait.session, question_id: wait.question.id))
         end
       rescue ArgumentError => e
         "Error: #{e.message}"
@@ -179,6 +181,10 @@ module Samagotchi
 
       def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      # A worker_gone wait's outcome when the child's worker never came up
+      # (#boot_result).
+      DID_NOT_START = "did_not_start"
+
       REPORT_NEXT_REPLY = "chi brings the child's next reply here by itself; don't wait for it with delegate_result."
 
       # Outcomes that tell the parent something about the child's state.
@@ -254,8 +260,8 @@ module Samagotchi
         when :no_reply
           result(child_id, status, "#{no_reply_text(wait, child_id, strategy: strategy)}; its session shows what happened")
         when :worker_gone
-          result(child_id, status,
-                 "the child's worker is gone (it stopped or crashed); delegate with session: #{child_id} starts it again with a message")
+          gone = wait.outcome == DID_NOT_START ? WorkerLink.did_not_start : "the child's worker is gone (it stopped or crashed)"
+          result(child_id, status, "#{gone}; delegate with session: #{child_id} starts it again with a message")
         else
           timeout_result(child_id, timeout, reports: reports)
         end
@@ -280,11 +286,29 @@ module Samagotchi
         DelegateCursors.update(parent_id, child_id, state_dir: state_dir) { |cursor| cursor.with(turn: turn) }
       end
 
-      # A new child's baseline: as spawned, before its first turn ran.
+      # A new child's baseline: as spawned, before its first turn ran, and
+      # its first turn (Session#first_turn_id, the prompt's turn) as the
+      # one waited for: queued (ReplyWait::Target.from_cursor), so the
+      # window between its worker going live and that turn's mark doesn't
+      # read as a merge into another turn.
       # @param child [Session] the session spawn_session returned
       def mark_started(parent_id, child, state_dir:)
         DelegateCursors.update(parent_id, child.id, state_dir: state_dir) do |cursor|
-          cursor.with(turn: nil).with_baseline(ReplyWait.baseline_of(child, question_id: nil))
+          cursor.with(turn: child.first_turn_id).with_baseline(ReplyWait.baseline_of(child, question_id: nil))
+        end
+      end
+
+      # How Delegate's boot await ended when no worker came up
+      # (Delegate.await_worker): :gone is worker_gone ("its worker did not
+      # start"), :timeout and :canceled read as a wait's own.
+      # @param boot [Symbol] :gone, :timeout or :canceled
+      def boot_result(child_id, boot, timeout:, peers:)
+        reports = reports_mode(peers)
+        case boot
+        when :canceled then canceled_result(child_id, reports: reports)
+        when :timeout then timeout_result(child_id, timeout, reports: reports)
+        else finish(ReplyWait::Result.new(status: :worker_gone, outcome: DID_NOT_START), child_id, timeout: timeout,
+                                                                                           reports: reports)
         end
       end
 

data/lib/samagotchi/tools/list_sessions.rb

@@ -31,9 +31,9 @@ module Samagotchi
         folder = cwd.to_s.strip.empty? ? nil : File.expand_path(cwd.to_s.strip)
         own = own_session(peers)
         project = folder ? nil : own_project(peers, own)
-        summaries = SessionManager.session_summaries(cwd: folder, limit: LIMIT, include_tests: false,
-                                                     exclude: peers.session_id, state_dir: peers.state_dir,
-                                                     project_root: project)
+        summaries = SessionManager.session_rows(cwd: folder, limit: LIMIT, include_tests: false,
+                                                exclude: peers.session_id, state_dir: peers.state_dir,
+                                                project_root: project)
         if summaries.empty?
           return "No other chi sessions in this project (#{File.basename(project)}); cwd \"/\" lists every project's." if project
 
@@ -41,12 +41,12 @@ module Samagotchi
         end
 
         lines = summaries.map do |s|
-          state = s[:live] ? "live" : "not live"
-          relation = if s[:parent_id] == peers.session_id then "  child"
-                     elsif own&.parent_id && s[:id] == own.parent_id then "  parent"
+          state = s.live ? "live" : "not live"
+          relation = if s.parent_id == peers.session_id then "  child"
+                     elsif own&.parent_id && s.id == own.parent_id then "  parent"
                      else ""
                      end
-          "#{s[:short_id]}  #{state}  #{s[:busy] ? "running" : "idle"}#{relation}  #{Paths.tilde(s[:cwd])}  #{s[:preview].inspect}"
+          "#{s.short_id}  #{state}  #{s.busy ? "running" : "idle"}#{relation}  #{Paths.tilde(s.cwd)}  #{s.preview.inspect}"
         end
         scope = project ? " in this project (#{File.basename(project)}; cwd \"/\" for every project)" : ""
         <<~TEXT.chomp

data/lib/samagotchi/update_command.rb

@@ -22,8 +22,8 @@ require "json"
 module Samagotchi
   # `chi update`: brings an installed chi up to date in one go: the system
   # bundle, the shipped bundles the user installed, and the macOS helper.
-  # Unedited things update; edited ones merge or stay behind (.md) or are replaced
-  # and reported (hooks, plugin, rules, which didn't load once edited). Live
+  # Unedited things update; edited ones merge or stay behind (.md) or are replaced,
+  # copied to the trash first, and reported (hooks, plugin, rules, scripts). Live
   # workers and a running chi web are reported, never restarted. The bundles
   # chi didn't ship are only checked, under the chi that will run them
   # (BundleCommand::InstalledCheck): what it finds is rows that fail nothing.
@@ -297,10 +297,14 @@ module Samagotchi
       earlier = [] if %i[installed skipped failed].include?(result.status)
       row = Row.new(component: "system bundle", from: result.from, to: result.to)
       notes = file_notes(row, system::BUNDLE_NAME, result.to, result.merged, result.behind, result.trash_copy, earlier: earlier)
+      # What the run warned of (a Checksum mismatch, a file it skipped) goes
+      # on its row, as ensure! echoes it.
+      warnings = Array(result.warnings)
+      warned = [*notes, *warnings]
       case result.status
-      when :installed then done(row, :install)
-      when :updated then done(row, :update, notes.empty? ? nil : notes.join("; "))
-      when :restored then done(row, :restore, notes.empty? ? nil : notes.join("; ")).tap { |r| r.to = nil }
+      when :installed then done(row, :install, warnings.empty? ? nil : warnings.join("; "))
+      when :updated then done(row, :update, warned.empty? ? nil : warned.join("; "))
+      when :restored then done(row, :restore, warned.empty? ? nil : warned.join("; ")).tap { |r| r.to = nil }
       when :merged, :up_to_date then same_version(row, notes + result.warnings, changed: result.merged.any?)
       when :newer_installed then skipped(row, ["newer than this chi's #{result.to}: left", *notes].join("; ")).tap { |r| r.to = nil }
       when :skipped then skipped(row, result.error)
@@ -352,7 +356,7 @@ module Samagotchi
       notes = file_notes(row, update.name, update.to || update.from, update.merged, update.behind, update.trash_copy, earlier: earlier)
       case update.status
       when :would_update, :updated
-        notes = [adds(update.adds), *notes, replaced(update.replaced), *update.kept_own].compact
+        notes = [adds(update.adds), *notes, replaced(update.replaced), *update.kept_own, update.note].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
       when :would_merge, :merged, :up_to_date then same_version(row, [*notes, update.note, update.manifest].compact, changed: Array(update.merged).any?)
       when :skipped then skipped(row, [update.note, *notes].join("; "))
@@ -526,7 +530,7 @@ module Samagotchi
     def replaced(files)
       return nil if files.empty?
 
-      "#{@dry_run ? "would replace" : "replaced"} edited #{files.join(", ")} (it wasn't loading)"
+      "#{@dry_run ? "would replace" : "replaced"} edited #{files.join(", ")} (a copy goes to the trash first)"
     end
 
     def print_table(rows)

data/lib/samagotchi/verify_fresh.rb

@@ -7,6 +7,8 @@ require_relative "atomic_file"
 require_relative "log"
 require_relative "session"
 require_relative "session_metrics"
+require_relative "session_row"
+require_relative "worker_link"
 require_relative "steer"
 require_relative "verify_anchor"
 require_relative "verify_fresh_origin"
@@ -37,10 +39,6 @@ module Samagotchi
     # The child's first message, after the claim.
     ASK = "Verify this claim against the files here. You have none of the original session's context. " \
           "End with a line `Verdict: confirmed|refuted|unclear — <one-line reason>`."
-    # How long a child whose worker hasn't come up yet counts as running
-    # (Tools::Delegate::STARTING_GRACE_SECONDS).
-    STARTING_GRACE_SECONDS = 15
-
     # A start refused: the HTTP +status+, the error +code+ and its words.
     class Refused < StandardError
       attr_reader :status, :code
@@ -257,15 +255,13 @@ module Samagotchi
     private_class_method :locked
 
     # A child runs while its worker runs a turn, or while it is marked
-    # running and its worker is on its way (Tools::Delegate.running?).
+    # running and its worker is on its way (SessionRow.running_or_starting?,
+    # the delegates' rule).
     def child_running?(child_id, state_dir)
       child = Session.summary_from_file(Session.session_file(child_id, state_dir: state_dir)) or return false
-      return false unless child.status == Session::STATUS_RUNNING
-      return true if SessionManager.session_owner(child_id, state_dir: state_dir)&.worker?
-
-      Time.now - Time.iso8601(child.updated_at.to_s) < STARTING_GRACE_SECONDS
-    rescue ArgumentError
-      false
+      live = WorkerLink.resolve(Session.session_dir(child_id, state_dir: state_dir), unlink: false).worker_owned?
+      SessionRow.running_or_starting?(saved_status: child.status, live: live,
+                                      busy: live && child.status == Session::STATUS_RUNNING, updated_at: child.updated_at)
     end
     private_class_method :child_running?
 

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/vision_support.rb

@@ -21,15 +21,15 @@ module Samagotchi
       def no? = value == false
     end
 
-    # @param target [HostRegistry::ModelTarget]
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup);
+    #   its target is the one the probes ask
     # @param profile [ModelProfile, nil] the model's prompt profile (native)
     # @param adapter [LLM::OpenAIChat, nil] the chat host's adapter
-    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all (specs)
-    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
     # @return [Answer]
-    def self.for(target, names:, profile: nil, adapter: nil, models: nil)
+    def self.for(lookup, profile: nil, adapter: nil)
+      target = lookup.target
       entry = target.entry
-      configured = configured(target, entry, models, names)
+      configured = configured(lookup)
       return configured if configured&.no?
 
       if entry.chat?
@@ -45,18 +45,15 @@ module Samagotchi
       marker.is_a?(String) && !marker.empty? ? marker : nil
     end
 
-    def self.configured(_target, entry, models, names)
-      models ||= begin
-        ModelSettings.all
-      rescue StandardError
-        {}
-      end
-      if (setting = ModelSettings.find(names, :vision, models: models))
+    def self.configured(lookup)
+      if (setting = lookup.model(:vision))
         return Answer.new(value: setting.value, reason: setting.value ? nil : "models: #{setting.key} sets vision: false")
       end
-      return nil if entry.vision.nil?
 
-      Answer.new(value: entry.vision, reason: entry.vision ? nil : "hosts.#{entry.name} sets vision: false")
+      vision = lookup.host(:vision)
+      return nil if vision.nil?
+
+      Answer.new(value: vision, reason: vision ? nil : "hosts.#{lookup.host_name} sets vision: false")
     end
 
     def self.native(target, _entry, profile, trust_config:)