samagotchi 0.155.0 → 0.157.0

data/lib/samagotchi/turn_stages/objectives.rb

@@ -14,78 +14,62 @@ module Samagotchi
     # audit of what comes in at a turn's start and what goes out at its end
     # (ObjectivesAudit), the view announced when it changed, and the model's
     # proposals kept as cards until the turn is over. Its state is those
-    # proposals under their mutex, the last view announced and the audit.
+    # proposals under their mutex and the last view announced (under the
+    # event lock); the audit is built per call.
     class Objectives
       # @param side_judgments [SideJudgments] the Engine's side asks (the audit's kinds)
       # @param host_registry [HostRegistry] System 1's client resolves its host here
-      # @param state_dir [#call] the sessions dir
-      # @param recording [#call] (client, judgment, session, mode:) → the client saving its runs
-      # @param runs [#call] the Engine's SystemOne::Runs
-      # @param synchronize [#call] (&block) runs the block under the event lock (Engine#synchronize_events)
-      # @param announce [#call] (event) tells the observers (Engine#announce)
-      # @param running [#call] the running turn's conversation, nil between turns (Engine#live_conversation)
-      # @param show_card [#call] (**card) shows a card (Engine#show_card)
-      def initialize(side_judgments:, host_registry:, state_dir:, recording:, runs:, synchronize:, announce:, running:, show_card:)
+      def initialize(side_judgments:, host_registry:)
         @side_judgments = side_judgments
-        @state_dir = state_dir
-        @synchronize = synchronize
-        @announce = announce
-        @running = running
-        @show_card = show_card
+        @host_registry = host_registry
         # The last view announced (#announce), under the event lock.
         @announced = nil
         # The model's proposals until the turn is over (#finally).
         @proposals = []
         @proposals_mutex = Mutex.new
-        # With saving off nothing would come of an ask, so none is made.
-        @audit = ObjectivesAudit.new(
-          side: side_judgments, state_dir: state_dir,
-          client_for: lambda do |judgment, session|
-            next nil unless runs.call.on?
-
-            recording.call(SystemOne::Client.from_config(host_registry: host_registry, mode: ObjectivesAudit::MODE, tag: :system_one),
-                           judgment, session, mode: nil)
-          end
-        )
       end
 
       # System 1 on the objectives, in audit (ObjectivesAudit), at a turn's
       # start: the owner's turns only, and for a message a person's: a
       # reminder's or a delegate's prompt isn't one.
-      def incoming(turn)
+      # @param recorder [SystemOne::Recorder] the audit's runs (built for this call)
+      def incoming(turn, recorder:)
         return unless turn.prompt.is_a?(String) && turn.origin.human? && OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
 
-        @audit.incoming(turn.session, turn.prompt)
+        audit(turn.context.state_dir, recorder).incoming(turn.session, turn.prompt)
       end
 
       # The turn's answer, after the end event and before :after_turn (the
       # caller skips a canceled or exhausted turn): the owner's turns only.
-      def outgoing(turn, result)
+      # @param recorder [SystemOne::Recorder] the audit's runs (built for this
+      #   call: after a before_turn hook's model switch, the new model)
+      def outgoing(turn, result, recorder:)
         return unless OwnerPrompt.turn?(session: turn.session, author: turn.origin.author)
 
-        @audit.outgoing(turn.session, result.text)
+        audit(turn.context.state_dir, recorder).outgoing(turn.session, result.text)
       end
 
       # A note added between turns (Engine#add_context_note): incoming too.
-      def note(session, note) = @audit.note(session, note)
+      # @param recorder [SystemOne::Recorder] the audit's runs (built for this call)
+      # @param state_dir [String] the sessions dir
+      def note(session, note, recorder:, state_dir:) = audit(state_dir, recorder).note(session, note)
 
       # The session's objectives as the page draws them (Objectives.view), when
       # that differs from the last announced: after an edit (its file written,
       # pending), once a list note is in, at a turn's end (its moves) and after
-      # a rollback. A session with no list announces nothing. It only informs:
-      # a failure is logged, never the turn's.
-      def announce(session)
-        return unless session
-
-        @synchronize.call do
-          view = Samagotchi::Objectives.view(session.id, session.messages, state_dir: @state_dir.call, running: @running.call&.dup)
-          next if view.nil? || view == @announced
-
-          @announced = view
-          @announce.call({ type: :objectives_updated, session_id: session.id, **view })
-        end
-      rescue StandardError => e
-        Log.warn(:turn, "objectives_announce_failed", error: e.class.name, msg: e.message)
+      # a rollback. A session with no list announces nothing. The caller
+      # (Engine#announce_objectives) holds the event lock, the one guard of
+      # the last view, announces the event and logs a failure: it only
+      # informs, never fails a turn.
+      # @param state_dir [String] the sessions dir
+      # @param running [Array<Hash>, nil] the running turn's conversation (Engine#live_conversation), nil between turns
+      # @return [Hash, nil] the :objectives_updated event to announce, nil when the view is the same
+      def announce(session, state_dir:, running:)
+        view = Samagotchi::Objectives.view(session.id, session.messages, state_dir: state_dir, running: running&.dup)
+        return if view.nil? || view == @announced
+
+        @announced = view
+        { type: :objectives_updated, session_id: session.id, **view }
       end
 
       # A change the model proposes (the objectives tool), kept until the turn
@@ -108,9 +92,15 @@ module Samagotchi
       # failed or rolled-back turn keeps none, and its proposals are dropped
       # here so the next turn does not show them either: their Apply card
       # would sit after a turn whose `objectives propose` call is not in the
-      # history (a rollback after Ctrl-C drops it).
+      # history (a rollback after Ctrl-C drops it). The caller
+      # (Engine#show_objective_proposals) shows the cards.
+      # @return [Array<Hash>] the completed turn's cards (Engine#show_card's
+      #   arguments); none for any other ending
       def finally(turn)
-        turn.completed? ? show_proposals : discard_proposals(turn)
+        return proposal_cards if turn.completed?
+
+        discard_proposals(turn)
+        []
       end
 
       # For specs: the audit's asks' thread for +kind+ (ObjectivesAudit's
@@ -122,15 +112,13 @@ module Samagotchi
 
       private
 
-      def show_proposals
-        drain_proposals.each do |proposal|
+      def proposal_cards
+        drain_proposals.map do |proposal|
           id = "objectives-#{SecureRandom.hex(4)}"
-          @show_card.call(source: Samagotchi::Objectives::SOURCE, id: id, title: proposal.title, body: proposal.body,
-                          actions: [{ label: "Apply", command: proposal.action_line(id) },
-                                    { label: "Dismiss", command: "/objectives --card #{id} dismiss" }])
+          { source: Samagotchi::Objectives::SOURCE, id: id, title: proposal.title, body: proposal.body,
+            actions: [{ label: "Apply", command: proposal.action_line(id) },
+                      { label: "Dismiss", command: "/objectives --card #{id} dismiss" }] }
         end
-      rescue StandardError => e
-        Log.warn(:turn, "objectives_proposal_failed", error: e.class.name, msg: e.message)
       end
 
       def discard_proposals(turn)
@@ -141,6 +129,22 @@ module Samagotchi
       def drain_proposals
         @proposals_mutex.synchronize { @proposals.slice!(0..) }
       end
+
+      # The audit for one call, over the values it is given: nothing of it
+      # is kept. Its client is asked for only once an active objective is
+      # there (ObjectivesAudit#ask), and with saving off nothing would come
+      # of an ask, so none is made.
+      def audit(state_dir, recorder)
+        ObjectivesAudit.new(
+          side: @side_judgments, state_dir: state_dir,
+          client_for: lambda do |judgment, session|
+            next nil unless recorder.saving?
+
+            recorder.wrap(SystemOne::Client.from_config(host_registry: @host_registry, mode: ObjectivesAudit::MODE, tag: :system_one),
+                          judgment, session, mode: nil)
+          end
+        )
+      end
     end
   end
 end

data/lib/samagotchi/turn_stages/toolkit_suggestion.rb

@@ -23,17 +23,11 @@ module Samagotchi
       # @param host_registry [HostRegistry] System 1's client resolves its host here
       # @param toolkit_binding [ToolkitBinding] the kits, #suggest and #fell_back
       # @param tools [Tools::Registry] the registered tools, for the snapshot
-      # @param state_dir [#call] the sessions dir (the suggestion log's place)
-      # @param recording [#call] (client, judgment, session, mode:) → the client saving its runs
-      # @param runs [#call] the Engine's SystemOne::Runs
-      def initialize(side_judgments:, host_registry:, toolkit_binding:, tools:, state_dir:, recording:, runs:)
+      def initialize(side_judgments:, host_registry:, toolkit_binding:, tools:)
         @side_judgments = side_judgments
         @host_registry = host_registry
         @toolkit_binding = toolkit_binding
         @tools = tools
-        @state_dir = state_dir
-        @recording = recording
-        @runs = runs
         @pending = nil
         @pending_turn = nil
         @warmup_thread = nil
@@ -52,12 +46,14 @@ module Samagotchi
       # snapshot. Audit never blocks: the thread logs its line. On mode
       # keeps the ask's Pending for +turn+, which #settle joins before
       # apply_toolkit!, with the turn's controller as the request's cancel
-      # controller.
+      # controller. The suggestion log is in the turn's sessions dir
+      # (TurnContext#state_dir).
+      # @param recorder [SystemOne::Recorder] the ask's runs (built for this call)
       # @return [ToolkitSuggest::Pending, nil] nil unless the turn joins an ask
-      def start(turn)
+      def start(turn, recorder:)
         @pending = nil
         @pending_turn = turn
-        @pending = ask(turn)
+        @pending = ask(turn, recorder)
       end
 
       # On mode, before apply_toolkit!: wait for +turn+'s ask (#start) up to
@@ -154,14 +150,14 @@ module Samagotchi
       # never reached #start) is never touched.
       def pending_for(turn) = (@pending if @pending_turn.equal?(turn))
 
-      def ask(turn)
+      def ask(turn, recorder)
         mode = Config.get("toolkit.suggest.mode").to_s
         return if mode == "off"
 
         joined = mode == "on"
         session = turn.session
         default = Toolkit.of(session.toolkit)
-        log = suggestion_log
+        log = suggestion_log(turn.context.state_dir)
         # The predicate checks the session first; the kits (memory kits are
         # read from disk) and the log (read whole) only when it gets there.
         kits = nil
@@ -185,8 +181,8 @@ module Samagotchi
           return
         end
 
-        client = @recording.call(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit),
-                                 ToolkitSuggest::JUDGMENT, session, mode: Config.get("toolkit.suggest.mode").to_s)
+        client = recorder.wrap(SystemOne::Client.from_config(host_registry: @host_registry, mode: "on", tag: :toolkit),
+                               ToolkitSuggest::JUDGMENT, session, mode: Config.get("toolkit.suggest.mode").to_s)
         return unless client
 
         # The warm-up's only value is the cache: the real ask never queues
@@ -215,7 +211,7 @@ module Samagotchi
           state: { project: state[:project].dup.freeze, prompt: state[:prompt].dup.freeze }.freeze
         )
         threshold = Config.get("toolkit.suggest.threshold")
-        runs = session.scratch ? nil : @runs.call
+        runs = session.scratch ? nil : recorder.runs
         pending = ToolkitSuggest::Pending.new(log: log, joined: joined,
                                               acted: runs && ->(judged, did) { runs.acted(judged.fields[:run_id], did) },
                                               timeout_seconds: SystemOne::Client.configured_timeout_ms / 1000.0)
@@ -253,8 +249,8 @@ module Samagotchi
         end
       end
 
-      def suggestion_log
-        SideJudgments.log(ToolkitSuggest.log_path(@state_dir.call), tag: :toolkit, event: "toolkit_suggest_log_failed")
+      def suggestion_log(state_dir)
+        SideJudgments.log(ToolkitSuggest.log_path(state_dir), tag: :toolkit, event: "toolkit_suggest_log_failed")
       end
     end
   end

data/lib/samagotchi/turn_stages/verify_anchors.rb

@@ -17,21 +17,20 @@ module Samagotchi
     # against its source session as the turn begins; at its end (inside
     # Engine#end_turn's event step) the opening's stamp, a Revise turn's
     # draft checked and a Verify turn's verdict recorded. No state of its
-    # own: it reads the turn, and the sessions it loads from the state dir.
+    # own: it reads the turn, and the sessions it loads from the state dir
+    # it is given.
     class VerifyAnchors
-      # @param state_dir [#call] the sessions dir (a fresh Verify child's parent is loaded from it)
-      def initialize(state_dir:)
-        @state_dir = state_dir
-      end
-
       # A Verify turn's claim (Engine#begin_turn), when its quote is in the
       # source session's answer for that turn; nil (logged) otherwise.
       # @param anchor [VerifyAnchor, nil]
+      # @param state_dir [String] the sessions dir (a fresh Verify child's
+      #   parent is loaded from it): the Engine's at the call, as no
+      #   TurnContext holds it yet
       # @return [VerifyAnchor, nil]
-      def verified(session, anchor)
+      def verified(session, anchor, state_dir:)
         return unless anchor
 
-        source = source_session(session, anchor)
+        source = source_session(session, anchor, state_dir)
         return unless source
 
         turn = AnswerTail.turn_slice(Array(source.messages), anchor.turn_id)
@@ -133,14 +132,14 @@ module Samagotchi
         comparison_text(Redact.text(answer, viewer)).include?(quote_text)
       end
 
-      def source_session(session, anchor)
+      def source_session(session, anchor, state_dir)
         return session unless session.verify_fresh
 
         fresh = session.verify_fresh
         return reject_verify(anchor, :fresh_anchor_mismatch) unless fresh.anchor == anchor
         return reject_verify(anchor, :fresh_parent_missing) unless session.parent_id
 
-        Session.load(session.parent_id, state_dir: @state_dir.call)
+        Session.load(session.parent_id, state_dir: state_dir)
       rescue ArgumentError, SystemCallError, IOError => e
         Log.warn(:turn, "verify_anchor_rejected", turn_id: anchor.turn_id, reason: :source_session_unavailable,
                                                    error: e.class.name)

data/lib/samagotchi/turn_stages/warmup.rb

@@ -17,22 +17,17 @@ module Samagotchi
       # @param prompt_warmup [PromptWarmup] the Engine's warm-up (the kernel asks it for a slot pin)
       # @param kernel [KernelLoop] the warm-up prompt, the last slot, warmed_up!
       # @param turn_state [TurnState] whether steers are carried to the next turn
-      # @param model_settings [SessionModelSettings] the next turn's LLM context strategy
-      # @param model [#call] the effective model now (Engine#effective_model)
-      # @param system_prompt [#call] (model) the system prompt (Engine#system_prompt)
-      # @param reminders_due [#call] whether a reminder is due (Engine#reminders_due?)
-      # @param next_turn_waiting [#call] whether the next turn starts at once or none follows
-      #   (Engine#next_turn_waiting, called)
-      def initialize(prompt_warmup:, kernel:, turn_state:, model_settings:, model:, system_prompt:, reminders_due:,
-                     next_turn_waiting:)
+      # @param model_settings [SessionModelSettings] the effective model now, the next turn's LLM context strategy
+      # @param reminder_queue [ReminderQueue] whether a reminder is due
+      # @param system_prompt [#call] (model) the system prompt (Engine#system_prompt): called last, only
+      #   once every check passed, as building it has side effects (the memory index metric, the prompt notes)
+      def initialize(prompt_warmup:, kernel:, turn_state:, model_settings:, reminder_queue:, system_prompt:)
         @prompt_warmup = prompt_warmup
         @kernel = kernel
         @turn_state = turn_state
         @model_settings = model_settings
-        @model = model
+        @reminder_queue = reminder_queue
         @system_prompt = system_prompt
-        @reminders_due = reminders_due
-        @next_turn_waiting = next_turn_waiting
       end
 
       # After a completed turn, prefill the next turn's prompt up to its user
@@ -40,14 +35,18 @@ module Samagotchi
       # local llama.cpp host on the native loop, and not when the next turn's
       # start differs anyway or starts at once: a reminder due, a continue
       # offer (the turn ran out of steps), a carried steer or queued input.
-      # Never fails the turn.
-      def after(turn, result)
+      # Never fails the turn. Each read comes only once the checks before it
+      # passed: the model resolved after the turn's own outcome, the probe
+      # and the prompt only on a target.
+      # @param next_turn_waiting [#call, nil] the host's probe: true when the next turn starts at once or none
+      #   follows (Engine#next_turn_waiting); nil: neither
+      def after(turn, result, next_turn_waiting:)
         return if result.canceled? || result.resumable?
 
-        model = @model.call
+        model = @model_settings.effective_model
         client = model.client
         return unless target?(model, client)
-        return if @reminders_due.call || @turn_state.carried_steers? || @next_turn_waiting.call
+        return if @reminder_queue.due? || @turn_state.carried_steers? || next_turn_waiting&.call
 
         messages = ContextNote.with_system_head(turn.session.messages.dup, { role: "system", content: @system_prompt.call(model) })
         # Under the next turn's strategy (a /model switch may have changed it);

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.155.0"
+  VERSION = "0.157.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] ConfigFile.model_settings (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
-        ConfigFile.model_settings
-      rescue StandardError
-        {}
-      end
-      if (setting = ConfigFile.model_setting(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:)