samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/reply_wait/poll.rb

@@ -5,7 +5,7 @@ require_relative "../session_inbox"
 require_relative "../turn_checkpoint"
 require_relative "../continue_offer"
 require_relative "../steer"
-require_relative "../worker_link"
+require_relative "liveness"
 
 module Samagotchi
   module ReplyWait
@@ -72,13 +72,17 @@ module Samagotchi
       # @return [Result, nil]
       def look
         look_at_input
+        # Before the load: the turn it names began before what the load sees.
+        merge = merge_record
         session = Session.load(@id, state_dir: @state_dir)
+        # Who runs it, read once for this look's checks.
+        @live = Liveness.new(@id, state_dir: @state_dir)
         if (result = removed(session))
           return result
         end
 
         note_own_running(session)
-        follow_merge(session)
+        follow_merge(session, merge)
         reply(session) || settled_turn(session) || status_end(session) || question(session) || held(session) || canceled ||
           ended_before_reply(session) || ended_before_turn(session) || turn_end(session) || owner_gone(session) ||
           message_waiting || timed_out
@@ -106,8 +110,11 @@ module Samagotchi
         Result.new(status: :no_reply, outcome: "removed", session: session)
       end
 
+      # Its turn ran, or a drain merged it (its merge record): a dequeue's
+      # tombstone that lost the claim to the drain is a stray too.
       def turn_ran?(session)
-        session.last_turn&.enqueued_id == @turn || !SessionInbox.reply_for(@session_dir, @turn).nil?
+        session.last_turn&.enqueued_id == @turn || !SessionInbox.reply_for(@session_dir, @turn).nil? ||
+          !SessionInbox.merged_into(@session_dir, @turn).nil?
       end
 
       def note_own_running(session)
@@ -119,14 +126,37 @@ module Samagotchi
 
       # Taken but never run as a turn of its own: a running turn's drain
       # merged it as a steer, so that turn's reply (or question) is its
-      # answer. Waited for as the next reply past the cursor, as without
-      # turn:, never as a turn that will not come.
-      def follow_merge(session)
-        return unless @turn && @claimed && !@seen_own && !@own_turn_input &&
-                      ReplyWait.merged_elsewhere?(session, @turn, @baseline, @session_dir)
-
-        @turn = nil
-        @seen_running = running?(session)
+      # answer. With the drain's merge record (SessionInbox.mark_merged)
+      # the wait is that turn's from here on, as if it had been bound to it
+      # (#follow_into). Without one (a 0.156 worker, a turn with no id, a
+      # merge from before the update) the merge is inferred
+      # (ReplyWait.merged_elsewhere?) and waited for as the next reply past
+      # the cursor, as without turn:, never as a turn that will not come.
+      def follow_merge(session, merge)
+        return unless may_follow?
+
+        if merge
+          follow_into(session, merge)
+        elsif ReplyWait.merged_elsewhere?(session, @turn, @baseline, @session_dir)
+          @turn = nil
+          @seen_running = running?(session)
+        end
+      end
+
+      def may_follow? = @turn && @claimed && !@seen_own && !@own_turn_input
+
+      def merge_record = may_follow? ? SessionInbox.merged_into(@session_dir, @turn) : nil
+
+      # Bound to the turn that took it, once (its own input ran as its own
+      # turn). Not running in this look, which loaded after the record:
+      # that turn is over (its end, its reply, its settle say how), and a
+      # turn that ended after the merge with last_turn not its is past it
+      # (#own_turn_end).
+      def follow_into(session, merge)
+        @turn = merge.into
+        @own_turn_input = true
+        note_own_running(session)
+        @merged_at = merge.at unless @seen_own
       end
 
       def reply(session)
@@ -172,9 +202,7 @@ module Samagotchi
       end
 
       # A worker holds the session's lock (a one-turn chi run's question is its own).
-      def worker_owned?
-        WorkerLink.resolve(Session.session_dir(@id, state_dir: @state_dir), unlink: false).worker_owned?
-      end
+      def worker_owned? = @live.worker_owned?
 
       # A participant's turn its worker holds while the owner's Continue
       # offer stands (Worker#run_input_files): it waits for the owner's
@@ -273,6 +301,7 @@ module Samagotchi
         # died), or it ended with no reply and a next turn ran and ended
         # between two looks. Waiting on would sit through those turns.
         return Result.new(status: :no_reply, session: session) if @seen_own && ReplyWait.past_own?(session, @turn, @own_base)
+        return Result.new(status: :no_reply, session: session) if @merged_at && ReplyWait.ended_after?(session, @merged_at)
 
         nil
       end
@@ -307,7 +336,7 @@ module Samagotchi
       def owner_gone(session)
         return nil unless @owner_grace
 
-        if SessionManager.session_owner(@id, state_dir: @state_dir)
+        if @live.owner?
           @gone_since = nil
         elsif ReplyWait.monotonic - (@gone_since ||= ReplyWait.monotonic) > @owner_grace
           return Result.new(status: :worker_gone, session: session)

data/lib/samagotchi/reply_wait/target.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "../delivery"
+require_relative "../session"
+
+module Samagotchi
+  module ReplyWait
+    # Which turn a reply wait waits for, and how: the one binding every
+    # caller builds (chi send --wait, chi answer, a participant's wait, the
+    # delegate tools and a delegate report), each with its constructor.
+    # #to_h is ReplyWait.call's kwargs (+cursor+, +baseline+,
+    # +owner_grace+, +turn+, +queued+, +ended_before+: ReplyWait.call's
+    # parameters say what each means); +report_turn_id+ (the turn_id of
+    # --format json's line, ParentWait's) is read on its own.
+    Target = Data.define(:turn, :report_turn_id, :queued, :ended_before, :cursor, :baseline, :owner_grace) do
+      def initialize(turn: nil, report_turn_id: nil, queued: false, ended_before: false, cursor: nil, baseline: nil,
+                     owner_grace: nil)
+        super
+      end
+
+      # A --new session's first message: its own turn, the ack's id (a
+      # file-delivered one's also names the outcome of a session command
+      # that runs no turn), so a worker that dies in it and the next one's
+      # settle end the wait (TurnCheckpoint.settled_turn). A message merged
+      # into a turn starting then falls back to that turn's reply
+      # (ReplyWait's turn: without queued:); no id (an older worker), the
+      # next reply. A prompt the session was created with has no delivery:
+      # its turn is the id the create gave it (+direct_turn+,
+      # Session#first_turn_id), and nothing can merge into it, so the wait
+      # is for that turn alone (ReplyWait's queued:).
+      # @param start [SessionAccess::WaitStart] prepare_wait's (its cursor
+      #   and baseline)
+      # @param delivered [SessionManager::DeliverResult, nil] nil when the
+      #   message started the session itself (no delivery)
+      # @param direct_turn [String, nil] that first turn's id, for a direct
+      #   start
+      def self.first_message(start, delivered, direct_turn: nil)
+        reads = { cursor: start&.cursor, baseline: start&.baseline, owner_grace: ReplyWait::GONE_AFTER }
+        return new(**reads) unless delivered || !direct_turn.to_s.strip.empty?
+
+        return new(turn: direct_turn, report_turn_id: direct_turn, queued: true, **reads) if delivered.nil?
+
+        new(turn: delivered.enqueued_id, report_turn_id: delivered.enqueued_id, **reads)
+      end
+
+      # A message to an existing session: its own turn, the ack's id. With
+      # --queue it runs as that turn, also when the turn running at the
+      # check ended before it went in (an idle worker's ack says next_step,
+      # and the file still runs as that turn). A plain one may run as its
+      # own turn or merge into a running one (a session left running by a
+      # dead worker, the busy check's owner gone; or a turn starting then):
+      # that turn's end is its answer (ReplyWait's follow_merge). A plain
+      # message the worker queued (its ack says queue: a participant's
+      # review turn was running, which takes no steer) is a --queue's. An
+      # ack with no id (an older worker): the next reply, reported as the
+      # turn that was running when it went in (start's own_turn).
+      # @param start [SessionAccess::WaitStart] read before it went in (its
+      #   running says the session was running then)
+      def self.message(start, delivered, queue:)
+        queue ||= delivered.delivery == Delivery::QUEUE
+        turn = delivered.enqueued_id
+        new(turn: turn, report_turn_id: turn || (start.own_turn if start.running && !queue), queued: queue && !turn.nil?,
+            cursor: start.cursor, baseline: start.baseline, owner_grace: ReplyWait::GONE_AFTER)
+      end
+
+      # --wait with no message: --turn's (+requested+), or the turn running
+      # now or whose continue offer stands (start's own_turn,
+      # ReplyWait.own_turn). Settled (idle, a turn ended, no question
+      # standing: a continue offer waits for its answer), its last turn's
+      # end is the answer (ended_before); with --turn, when that turn is the
+      # last one. A session no worker runs waits for whatever wakes one (no
+      # owner_grace).
+      # @param start [SessionAccess::WaitStart]
+      def self.wait_only(start, requested:)
+        turn = requested || start.own_turn
+        ended_before = requested ? start.last_turn_id == requested : start.settled
+        new(turn: turn, report_turn_id: turn || (start.last_turn_id if start.settled), ended_before: ended_before,
+            cursor: start.cursor, baseline: start.baseline, owner_grace: start.live ? ReplyWait::GONE_AFTER : nil)
+      end
+
+      # chi answer: the turn the question is about (start's own_turn: the
+      # one running, or the one whose continue offer stands), else the next
+      # reply.
+      def self.answer(start)
+        new(turn: start.own_turn, report_turn_id: start.own_turn, cursor: start.cursor, baseline: start.baseline,
+            owner_grace: ReplyWait::GONE_AFTER)
+      end
+
+      # A participant's --wait -m: their review turn just queued (+turn+),
+      # as --wait --turn T (their wait routes take only a turn of theirs).
+      def self.participant(start, turn:) = wait_only(start, requested: turn)
+
+      # A delegate's wait (DelegateWait, a delegate report) from the
+      # parent's DelegateCursor: the newest reply it was given, the child as
+      # it was then, and the turn a follow-up joined. The child's first turn
+      # (Session#first_turn_id: the prompt it was spawned with) runs as its
+      # own and nothing merges into it, so a wait bound to it is queued.
+      # @param cursor [Tools::DelegateCursor]
+      # @param child [Session, nil] the child as read now (its first_turn_id)
+      # @param owner_grace [Numeric, nil] nil: no gone check (a report's
+      #   look)
+      def self.from_cursor(cursor, child:, owner_grace: nil)
+        first = child&.first_turn_id
+        new(turn: cursor.turn, cursor: cursor.reply_file, baseline: cursor.baseline, owner_grace: owner_grace,
+            queued: !cursor.turn.to_s.empty? && cursor.turn == first)
+      end
+
+      # ReplyWait.call's kwargs (report_turn_id is ParentWait's, not one).
+      def to_h = { cursor: cursor, baseline: baseline, owner_grace: owner_grace, turn: turn, queued: queued,
+                   ended_before: ended_before }
+    end
+  end
+end

data/lib/samagotchi/reply_wait.rb

@@ -6,6 +6,7 @@ require_relative "session_inbox"
 require_relative "turn_checkpoint"
 require_relative "worker_link"
 require_relative "reply_wait/poll"
+require_relative "reply_wait/target"
 
 module Samagotchi
   # Loaded on first use: this autoload keeps SessionManager and its ~80
@@ -21,6 +22,12 @@ module Samagotchi
   # The delegate tools and `chi send --wait` wrap it in their own words.
   module ReplyWait
     POLL_INTERVAL = 0.5
+    # The one dead-worker rule: no owner of any kind this long while
+    # waiting (a Target's owner_grace) and the worker is gone (it died
+    # before it could mark the session). A caller that just spawned or woke
+    # a worker awaits it first (Tools::Delegate.await_worker,
+    # SendCommand#deliver_new), so a booting worker isn't read as gone.
+    GONE_AFTER = 5
     # A worker's sidecar feature (Bridge::FEATURES): its running turn's
     # checkpoint mark (InterruptedTurn#enqueued_id), a continue turn and a
     # Stop's last_turn carry the turn's enqueued_id (#own_turn).
@@ -209,7 +216,8 @@ module Samagotchi
     end
 
     # Whether +turn+ is a turn the caller can wait for: running now, queued
-    # as its own turn, or the last one to have ended.
+    # as its own turn, the last one to have ended, or an input a turn's
+    # drain merged (its merge record: the wait follows it to that turn).
     def known_turn?(session, session_dir:, turn:)
       id = turn.to_s
       return false if id.empty?
@@ -217,7 +225,7 @@ module Samagotchi
       running = session.status == Session::STATUS_RUNNING && session.interrupted_turn&.enqueued_id == id
       queued = SessionInbox.waiting_input(session_dir, id) == :turn_end
       ended = session.last_turn&.enqueued_id == id || !TurnCheckpoint.settled_turn(session_dir, id).nil?
-      running || queued || ended
+      running || queued || ended || !SessionInbox.merged_into(session_dir, id).nil?
     end
 
     # Whether the session's live worker names TURN_IDS_FEATURE.
@@ -287,6 +295,18 @@ module Samagotchi
       !ended.nil? && ended != own_base
     end
 
+    # Whether the session's last turn ended after +at+ (a Time): a turn
+    # that isn't own_turn_end's (its last_turn is checked first) ended
+    # after the turn a merge record named began, so that turn is over.
+    # Clock skew can't fire it: +at+ and every ended_at come from the
+    # same machine's clock (its workers'; a remote wait's Poll runs there).
+    def ended_after?(session, at)
+      ended = session.last_turn&.ended_at
+      !ended.to_s.empty? && Time.iso8601(ended.to_s) > at
+    rescue ArgumentError
+      false
+    end
+
     # @return [Result, nil] :done with the reply of the turn that ran the
     #   input +turn+ (its enqueued_id)
     def reply_for_turn(id, state_dir:, turn:)

data/lib/samagotchi/run_options.rb

@@ -213,6 +213,7 @@ module Samagotchi
                  chi desktop <install|upgrade|uninstall|status>   macOS "Send to chi" helper
                  chi models [--format json] [TEXT]   the models --model takes, from every host
                  chi home [set [--ruby PATH] | doctor]   the Ruby every chi launch boots
+                 chi project [init [DIR]]         this folder's project; init makes a folder in no git repository one
                  chi remote <add|ls|rm>           other machines' chi web, for chi --remote NAME
                  chi --remote NAME <send|answer|note|context|sessions|share|review> …   those commands on that machine (or CHI_REMOTE=NAME)
                  chi --remote NAME --attach ID | --resume ID | --dir DIR [-p TEXT]   a session on that machine, in this terminal

data/lib/samagotchi/sampling_settings.rb

@@ -11,18 +11,16 @@ module Samagotchi
   module SamplingSettings
     EMPTY = {}.freeze
 
-    # @param target [HostRegistry::ModelTarget]
-    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
-    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all (specs)
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup)
     # @return [Hash] frozen, symbol keys; may be empty
-    def self.for(target, names:, models: nil)
-      resolve(target, names, models).first
+    def self.for(lookup)
+      resolve(lookup).first
     end
 
     # "temperature=0.6 presence_penalty=1.5 (hosts.work, models: qwen)" for
     # /model, or nil when nothing is configured.
-    def self.summary(target, names:, models: nil)
-      params, sources = resolve(target, names, models)
+    def self.summary(lookup)
+      params, sources = resolve(lookup)
       return nil if params.empty?
 
       pairs = params.map { |key, value| "#{key}=#{value.nil? ? "(not sent)" : value.inspect}" }
@@ -37,16 +35,11 @@ module Samagotchi
       fields.map { |key, value| "#{key}=#{value.is_a?(String) ? value : JSON.generate(value)}" }.join(" ")
     end
 
-    def self.resolve(target, names, models)
-      models ||= begin
-        ModelSettings.all
-      rescue StandardError
-        {}
-      end
-      host = target.entry.sampling || EMPTY
-      model = ModelSettings.find(names, :sampling, models: models)
+    def self.resolve(lookup)
+      host = lookup.host(:sampling) || EMPTY
+      model = lookup.model(:sampling)
       sources = []
-      sources << "hosts.#{target.entry.name}" unless host.empty?
+      sources << "hosts.#{lookup.host_name}" unless host.empty?
       sources << "models: #{model.key}" if model
       [host.merge(model&.value || EMPTY).freeze, sources]
     end

data/lib/samagotchi/self_report.rb

@@ -4,6 +4,7 @@ require_relative "version"
 require_relative "config"
 require_relative "context_window"
 require_relative "degrade"
+require_relative "effective_model"
 require_relative "session"
 require_relative "log_path"
 require_relative "model_profile"
@@ -181,15 +182,12 @@ module Samagotchi
       Degrade.call(:config, "model_window_unreadable") do
         return nil unless model
 
-        registry = HostRegistry.new(env: env)
-        target = registry.resolve(model)
-        names = registry.lookup_names(model, target: target)
-        models = ModelSettings.all(env: env)
-        window = ContextWindow.setting(target, names: names, models: models)
+        effective = effective_model(model, env)
+        window = effective.window_setting
         return nil unless window
-        return [window.tokens, "hosts.#{target.entry.name}"] if window.source == :host_setting
+        return [window.tokens, "hosts.#{effective.host_name}"] if window.source == :host_setting
 
-        [window.tokens, "models: #{ModelSettings.find(names, :window_tokens, models: models).key}"]
+        [window.tokens, "models: #{effective.lookup.model(:window_tokens).key}"]
       end
     end
 
@@ -232,7 +230,7 @@ module Samagotchi
     # engine keys memory_write current_model_only): which `<name>.<key>.md`
     # overlays are this model's.
     def model_key_for(model, env)
-      ModelOverlay.key_for(HostRegistry.new(env: env).bare_name(model)) || "-"
+      ModelOverlay.key_for(registry(env).bare_name(model)) || "-"
     rescue StandardError
       ModelOverlay.key_for(model) || "-"
     end
@@ -243,7 +241,7 @@ module Samagotchi
     # without any. Read from the memories dirs now: a session's prompt
     # takes them at its next build (/stats names the ones it carries).
     def model_notes_for(model, env)
-      bare = HostRegistry.new(env: env).bare_name(model)
+      bare = registry(env).bare_name(model)
       key = ModelOverlay.key_for(bare)
       notes = ModelNotes.for(name: bare, key: key, fallback_key: fallback_model_key(model, key, env),
                              muted: session_muted(env), env: env, warn: false)
@@ -260,7 +258,7 @@ module Samagotchi
     def fallback_model_key(model, key, env)
       Degrade.call(:model, "fallback_key_unresolved") do
         typed = session_typed_model(env) || model
-        typed_key = ModelOverlay.key_for(HostRegistry.new(env: env).parse_qualified_model(typed).last)
+        typed_key = ModelOverlay.key_for(registry(env).parse_qualified_model(typed).last)
         typed_key == key ? nil : typed_key
       end
     end
@@ -311,7 +309,7 @@ module Samagotchi
     # Routed without model discovery, so an unqualified name may land on
     # another host at runtime after /models.
     def loop_for(model, env)
-      entry = HostRegistry.new(env: env).resolve(model).entry
+      entry = registry(env).resolve(model).entry
       return "-" unless entry
 
       return "native (raw prompt)" unless entry.chat?
@@ -327,15 +325,15 @@ module Samagotchi
     # chat host (api: openai or anthropic) has no /props, so it gets its model list
     # with the same timeouts: up/down and the ids it serves.
     def served_model_for(model, env)
-      registry = HostRegistry.new(env: env)
-      target = registry.resolve(model)
+      hosts = registry(env)
+      target = hosts.resolve(model)
       entry = target.entry
       bare = target.bare_model
       return "-" unless entry
       return "reported per turn (remote host)" if entry.remote?
       return chat_served_model_for(entry, bare, env) if entry.chat?
 
-      client = registry.client_for(entry)
+      client = hosts.client_for(entry)
       props = client.server_props(model: bare)
       return NO_PROPS if props.nil? || props.status == :http_error
       return "unknown (the server didn't answer; is it running?)" if props.status == :network_error
@@ -374,16 +372,12 @@ module Samagotchi
     # Offline, so no /props probe: where nothing is configured, a native
     # llama.cpp host's chat template decides at runtime.
     def profile_for(model, env)
-      registry = HostRegistry.new(env: env)
-      target = registry.resolve(model)
-      entry = target.entry
-      bare = target.bare_model
-      return "name-based (chat API: only strips thoughts)" if entry&.chat?
+      effective = effective_model(model, env)
+      return "name-based (chat API: only strips thoughts)" if effective.entry&.chat?
 
-      names = registry.lookup_names(model)
-      override = Config.resolve_with_origin("model.profile", env: env, cli_overrides: Config.cli_overrides)
-      result = ModelProfile.resolve(names: names, entry: entry, client: nil, bare_model: bare, override: override,
-                                    models: ModelSettings.all(env: env))
+      lookup = effective.lookup
+      result = ModelProfile.resolve(names: effective.names, entry: effective.entry, client: nil, bare_model: effective.bare,
+                                    override: lookup.global("model.profile"), models: lookup.models)
       name = result.profile.name
       case result.source
       when :config then "#{name} (config #{result.detail})"
@@ -397,11 +391,8 @@ module Samagotchi
     # The model's thinking level and where it came from (Thinking.resolve);
     # in a session's commands its own level first (SAMAGOTCHI_SESSION_THINKING).
     def thinking_for(model, env)
-      registry = HostRegistry.new(env: env)
-      target = registry.resolve(model)
       session = session_model(env) ? Thinking.session_level(env[SESSION_THINKING_ENV]) : nil
-      Thinking.explain(target, names: registry.lookup_names(model, target: target),
-                               models: ModelSettings.all(env: env), session: session).label
+      Thinking.explain(effective_model(model, env).lookup, session: session).label
     rescue StandardError => e
       "(unknown: #{e.message})"
     end
@@ -411,20 +402,28 @@ module Samagotchi
     # first (SAMAGOTCHI_SESSION_REASONING_HISTORY); a native host keeps the
     # running turn's on its own.
     def reasoning_history_for(model, env)
-      registry = HostRegistry.new(env: env)
-      target = registry.resolve(model)
-      return "native loop: the running turn's, always" unless target.entry&.chat?
+      effective = effective_model(model, env)
+      return "native loop: the running turn's, always" unless effective.entry&.chat?
 
       session = session_model(env) ? ReasoningHistory.session_level(env[SESSION_REASONING_HISTORY_ENV]) : nil
-      level, source = ReasoningHistory.resolve(target, names: registry.lookup_names(model, target: target),
-                                                       models: ModelSettings.all(env: env), session: session)
-      ReasoningHistory.label(level, source)
+      ReasoningHistory.label(*ReasoningHistory.resolve(effective.lookup, session: session))
     rescue StandardError => e
       "(unknown: #{e.message})"
     end
 
+    # The hosts chi self reads (HostRegistry.current: the process's shared
+    # one for ENV, a fresh one for another env).
+    def registry(env) = HostRegistry.current(env: env)
+
+    # +model+ as chi self reads its settings (EffectiveModel: every layer
+    # through its ModelLookup, with +env+). Raises as HostRegistry#resolve does.
+    # @return [EffectiveModel]
+    def effective_model(model, env)
+      EffectiveModel.of(registry(env), ModelChoice.new(name: model, typed: model))
+    end
+
     def host_for(model, env)
-      target = HostRegistry.new(env: env).resolve(model)
+      target = registry(env).resolve(model)
       entry = target.entry
       bare = target.bare_model
       return "(no hosts configured)" unless entry
@@ -437,7 +436,7 @@ module Samagotchi
     # The variable the host's API key comes from and whether it is set, or
     # comes from the Keychain (HostKeys); the key itself is never shown.
     def api_key_for(model, env)
-      name = HostRegistry.new(env: env).resolve(model).entry&.api_key_env
+      name = registry(env).resolve(model).entry&.api_key_env
       return "-" unless name
 
       state = { env: "set", keychain: "keychain" }.fetch(HostKeys.source(name, env: env), "unset")

data/lib/samagotchi/send_command.rb

@@ -4,6 +4,7 @@ require_relative "client_id"
 require_relative "delivery"
 require_relative "terminal_ui/formatting"
 require_relative "session"
+require_relative "worker_link"
 require_relative "session_commands"
 require_relative "parent_answers_command"
 require_relative "session_inbox"
@@ -17,6 +18,7 @@ require_relative "turn_flow"
 require_relative "guardrails/parent_approvals"
 require_relative "guardrails/parent_policy"
 require_relative "image_store"
+require_relative "effective_model"
 require_relative "host_registry"
 require_relative "model_profile"
 require_relative "vision_support"
@@ -24,7 +26,6 @@ require_relative "cli/command"
 require_relative "cli/flags"
 require_relative "cli/parent_wait"
 require_relative "send_command/parent_gate"
-require_relative "send_command/wait_target"
 require_relative "send_command/busy"
 require_relative "session_access/local"
 
@@ -193,16 +194,13 @@ module Samagotchi
     # @param typed [String, nil] the name the model was typed as (a session's model_typed)
     # @return [VisionSupport::Answer] value nil when unknown
     def self.vision_answer(model_name, registry: nil, typed: nil)
-      registry ||= HostRegistry.new
+      registry ||= HostRegistry.current
       name = ModelProfile.required_model_name(model_name)
-      target = registry.resolve(name)
-      names = registry.lookup_names(typed.to_s.strip.empty? ? name : typed, resolved: name, target: target)
-      entry = target.entry
-      return VisionSupport.for(target, adapter: registry.adapter_for(entry), names: names) if entry.chat?
-
-      profile = ModelProfile.resolve(names: names, entry: entry, client: target.client, bare_model: target.bare_model).profile
-      answer = VisionSupport.for(target, profile: profile, names: names)
-      props = target.client.server_props(model: target.bare_model)
+      model = EffectiveModel.of(registry, ModelChoice.new(name: name, typed: typed.to_s.strip.empty? ? name : typed))
+      return model.vision_support(nil) if model.chat?
+
+      answer = model.vision_support(model.profile_resolution.profile)
+      props = model.client.server_props(model: model.bare)
       return UNKNOWN_VISION if answer.no? && !props&.answered? && !configured_no?(answer)
 
       answer
@@ -521,9 +519,8 @@ module Samagotchi
       return report_command(session.id) if @sent_command
 
       start = @access.prepare_wait(session.id, session: session, created: true)
-      wait_for_reply(session.id, cursor: start.cursor, baseline: start.baseline,
-                                 timeout: options[:timeout],
-                                 **WaitTarget.first_message(@delivered, direct_turn: session.first_turn_id).to_h)
+      target = ReplyWait::Target.first_message(start, @delivered, direct_turn: session.first_turn_id)
+      wait_for_reply(session.id, target: target, timeout: options[:timeout])
     end
 
     # What chi send --new asks to create: through the worker (images, a
@@ -601,9 +598,8 @@ module Samagotchi
       return 1 unless deliver(id, prompt)
       return report_command(id) if @sent_command
 
-      target = WaitTarget.message(@delivered, queue: @queue, running: start.running,
-                                              running_turn: (start.own_turn if start.running))
-      wait_for_reply(id, cursor: start.cursor, baseline: start.baseline, timeout: options[:timeout], **target.to_h)
+      target = ReplyWait::Target.message(start, @delivered, queue: @queue)
+      wait_for_reply(id, target: target, timeout: options[:timeout])
     end
 
     # A participant's --wait -m (a review turn through chi --remote with
@@ -622,9 +618,8 @@ module Samagotchi
         return 1
       end
       start = @access.prepare_wait(id, turn: turn)
-      wait_for_reply(id, cursor: start.cursor, baseline: start.baseline, timeout: options[:timeout],
-                         owner_grace: start.live ? self.class::WORKER_GONE_AFTER : nil,
-                         **WaitTarget.after(start, requested: turn).to_h)
+      target = ReplyWait::Target.participant(start, turn: turn)
+      wait_for_reply(id, target: target, timeout: options[:timeout])
     end
 
     # --wait with no message: the session's next reply, sending nothing,
@@ -648,9 +643,8 @@ module Samagotchi
         error_line("chi send: turn #{requested_turn} is not a running, queued, or last ended turn")
         return 1
       end
-      target = WaitTarget.after(start, requested: requested_turn)
-      wait_for_reply(id, cursor: start.cursor, baseline: start.baseline,
-                         timeout: options[:timeout], owner_grace: start.live ? self.class::WORKER_GONE_AFTER : nil, **target.to_h)
+      target = ReplyWait::Target.wait_only(start, requested: requested_turn)
+      wait_for_reply(id, target: target, timeout: options[:timeout])
     end
 
     # A new idle session's first turn, with the images. Its worker's Bridge
@@ -675,7 +669,7 @@ module Samagotchi
       # its preview; the user can attach and send it again.
       unless result
         attach = @access.invocation.attach(session.id)
-        @info.puts("#{session.id}  failed: its worker did not start; the session is kept (#{attach})")
+        @info.puts("#{session.id}  failed: #{WorkerLink.did_not_start}; the session is kept (#{attach})")
         return false
       end
       unless result.accepted?