samagotchi 0.52.0 → 0.54.0

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -33,17 +33,15 @@ module Samagotchi
 
       def run
         provenance = Provenance.new(name: @name)
-        data = provenance.read
-        raise UninstallError, "Bundle '#{@name}' is not installed" unless data
+        bundle = provenance.record
+        raise UninstallError, "Bundle '#{@name}' is not installed" unless bundle
 
-        # Determine scope from flag or provenance
-        cli_scope = @scope.to_s.strip.empty? ? nil : @scope
-        raw = cli_scope || data[:scope]&.to_s
-        target_scope = raw.nil? || raw.strip.empty? ? "system" : raw
+        # The scope from the flag, else the record's
+        target_scope = @scope.to_s.strip.empty? ? bundle.effective_scope : @scope
         target_dir = MemoryPaths.scope_dir(target_scope) or raise UninstallError, "invalid scope: #{target_scope}"
 
-        files = data[:files] || {}
-        hooks = data[:hooks] || {}
+        files = bundle.files
+        hooks = bundle.hooks
         if files.empty? && hooks.empty?
           # No file list, just remove provenance
           FileUtils.rm_rf(provenance.bundle_dir)
@@ -99,7 +97,7 @@ module Samagotchi
         # ── Hooks removal (bundle-owned) ──────────────────────────
         # Hooks are stored under <bundle_dir>/hooks/ and are not part of the index.
         # Explicit removal for intent; the final rm_rf sweeps it anyway.
-        if hooks.is_a?(Hash) && !hooks.empty?
+        if hooks.any?
           hooks_dir = provenance.hooks_dir
           hooks.each do |hook_key, _meta|
             hook_key_str = hook_key.to_s
@@ -117,7 +115,7 @@ module Samagotchi
           FileUtils.rm_rf(provenance.hooks_dir)
         end
 
-        plugin_path = provenance.plugin_path(data)
+        plugin_path = provenance.plugin_path(bundle)
         @removed_files << "plugin/#{File.basename(plugin_path)}" if plugin_path && File.exist?(plugin_path)
         FileUtils.rm_rf(provenance.bundle_dir)
         true

data/lib/samagotchi/plugin/loader.rb

@@ -44,8 +44,8 @@ module Samagotchi
       # @return [Array<String>] the bundles whose plugin loaded
       def load_installed(registries, failures: nil, settings: {})
         loaded = []
-        MemoryBundle::Provenance.each_installed(holding: :plugin) do |bundle_name, data|
-          ok = load_bundle(bundle_name, data, registries, failures: failures, settings: settings[bundle_name.to_s] || {})
+        MemoryBundle::Provenance.each_installed(holding: :plugin) do |bundle_name, bundle|
+          ok = load_bundle(bundle_name, bundle, registries, failures: failures, settings: settings[bundle_name.to_s] || {})
           loaded << bundle_name if ok
         end
         loaded
@@ -56,10 +56,10 @@ module Samagotchi
       end
 
       # @return [Boolean] whether the plugin loaded
-      def load_bundle(bundle_name, data, registries, failures: nil, settings: {})
-        file = MemoryBundle::Provenance.new(name: bundle_name).plugin_path(data) unless data[:error]
+      def load_bundle(bundle_name, bundle, registries, failures: nil, settings: {})
+        file = MemoryBundle::Provenance.new(name: bundle_name).plugin_path(bundle) unless bundle.error?
         basename = file ? File.basename(file) : "plugin"
-        reason = data[:error] || unloadable_reason(file, data)
+        reason = bundle.error || unloadable_reason(file, bundle)
         return failed(bundle_name, basename, reason, failures) if reason
 
         api = nil
@@ -82,12 +82,12 @@ module Samagotchi
       def label(bundle_name, basename) = "#{basename} (bundle #{bundle_name})"
 
       # Why the installed file can't be loaded, or nil.
-      def unloadable_reason(file, data)
-        failure = MemoryBundle::Manifest.requires_chi_failure(data[:requires_chi], Samagotchi::VERSION)
+      def unloadable_reason(file, bundle)
+        failure = MemoryBundle::Manifest.requires_chi_failure(bundle.requires_chi, Samagotchi::VERSION)
         return failure if failure
         return "the file is missing" unless file && File.file?(file)
 
-        Hooks::BundleLoader.sha_mismatch(file, data[:plugin][:sha256], required: true)
+        Hooks::BundleLoader.sha_mismatch(file, bundle.plugin.sha256, required: true)
       end
 
       # module_eval the file into a fresh module in the bundle's namespace

data/lib/samagotchi/self_report.rb

@@ -406,8 +406,8 @@ module Samagotchi
     # "samagotchi-system 0.1.5 (shipped 0.1.5), other 1.0.0"
     def bundles_summary
       shipped = MemoryBundle::Manifest.read(dir: MemoryBundle::SystemBundle::GEM_BUNDLE_DIR).version rescue nil
-      installed = MemoryBundle::Provenance.each_installed.map do |name, data|
-        version = data[:version] || "?"
+      installed = MemoryBundle::Provenance.each_installed.map do |name, bundle|
+        version = bundle.version || "?"
         label = "#{name} #{version}"
         label += " (shipped #{shipped})" if name == MemoryBundle::SystemBundle::BUNDLE_NAME
         label

data/lib/samagotchi/send_command.rb

@@ -339,7 +339,7 @@ module Samagotchi
                                                                                   thinking: options[:thinking]),
                                                           state_dir: @state_dir)
                   end
-      rescue SessionManager::ContinueRefused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
+      rescue SessionContinue::Refused, SessionManager::ArchiveRefused, SessionManager::OwnedByTUI => e
         error_line("chi send: refused: #{e.message}")
         return 1
       rescue StandardError => e
@@ -481,26 +481,8 @@ module Samagotchi
     # (a bundle's too).
     def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
 
-    # The UI-only built-in command +text+ (stripped) is a line of (/stats,
-    # /exit, …), or nil: the worker never runs it, so chi send must not pass
-    # it on. What the UIs run: the line as the entry's match takes it — bare
-    # "exit" too (/exit's match), but not with arguments ("/exit --delete" is
-    # a UI line; "/stats please" is a prompt), as in a terminal.
-    # @return [Commands::Registry::Entry, nil]
-    def local_command(text)
-      line = text.to_s.strip
-      return nil unless command_like?(line) || line.match?(/\Aexit\z/i)
-
-      entry = SessionCommands.builtin_registry.lookup_local(line)
-      # Only the exact line the UI runs: "/stats please" is a prompt, and
-      # "/exit --delete" is left to the worker (the TUI runs it as /exit, the
-      # worker answers its unknown-command way). Bare "exit" is /exit's line
-      # as its match takes it; the reply names the command, /exit.
-      return nil unless entry
-      return entry if line == entry.name
-
-      line.match?(/\Aexit\z/i) ? entry : nil
-    end
+    # @return [Commands::Registry::Entry, nil] SessionCommands.ui_only_entry
+    def local_command(text) = SessionCommands.ui_only_entry(text)
 
     # A UI-only command: nothing is sent (with --new, no session is created
     # either). /stats points at its model-free reader and names the session;
@@ -525,13 +507,7 @@ module Samagotchi
       CLI::Exit::FAILED
     end
 
-    # Why a UI-only command isn't sent: /stats points at its model-free
-    # reader (naming the session when there is one).
-    def local_refusal(name, id)
-      return "#{name} is a terminal and web command; chi send doesn't run it" unless name == "/stats"
-
-      "#{name} is a terminal and web command; use chi sessions stats #{id ? id[0, 8] : "ID"}"
-    end
+    def local_refusal(name, id) = SessionCommands.ui_only_refusal(name, id, runner: "chi send")
 
     # --wait after a message that ran as a session command: no reply comes
     # for it. Its output shows where the session is open.

data/lib/samagotchi/session_commands.rb

@@ -141,6 +141,34 @@ module Samagotchi
       @builtin_registry ||= register_builtins(Commands::Registry.new).freeze
     end
 
+    # The UI-only built-in command +text+ is a line of (/stats, /exit, …), or
+    # nil: neither a worker nor a one-shot run (chi send, chi -p
+    # --non-interactive) runs it, so they refuse it rather than send it to
+    # the model as a prompt. What the UIs run: the line as the entry's match
+    # takes it — bare "exit" too (/exit's match), but not with arguments
+    # ("/exit --delete" is a UI line; "/stats please" is a prompt), as in a
+    # terminal.
+    # @return [Commands::Registry::Entry, nil]
+    def self.ui_only_entry(text)
+      line = text.to_s.strip
+      return nil unless line.start_with?("/", "!") || line.match?(/\Aexit\z/i)
+
+      entry = builtin_registry.lookup_local(line)
+      return nil unless entry
+      return entry if line == entry.name
+
+      line.match?(/\Aexit\z/i) ? entry : nil
+    end
+
+    # Why a UI-only command isn't run by +runner+ ("chi send"): /stats points
+    # at its model-free reader (naming the session +id+ when there is one).
+    # @return [String]
+    def self.ui_only_refusal(name, id, runner:)
+      return "#{name} is a terminal and web command; #{runner} doesn't run it" unless name == "/stats"
+
+      "#{name} is a terminal and web command; use chi sessions stats #{id ? id[0, 8] : "ID"}"
+    end
+
     # The name of this chi's own session command +line+ is (one a worker
     # runs), or nil. A worker that answers such a line unknown_command runs
     # an older chi that doesn't have it yet (/llm-context against 0.39.0):
@@ -488,7 +516,7 @@ module Samagotchi
 
         key = alias_name.strip.downcase
         warn_prefix = previous ? "warning: overwriting alias '#{key}' (#{previous} -> #{model_name}); " : ""
-        base = persist_default ? "runtime model set to #{model_name}#{model_note} and default updated" : "runtime model set to #{model_name}#{model_note}"
+        base = persist_default ? "runtime model set to #{model_name}#{model_note} and default updated#{thinking_note}" : "runtime model set to #{model_name}#{model_note}#{thinking_note}"
         ["#{warn_prefix}#{base}; alias '#{key}' -> '#{model_name}' persisted", true]
       else
         return ["--default requires a model name: usage /model --default <name> or /model <name> [--default]", false] if arg.empty?
@@ -497,14 +525,14 @@ module Samagotchi
           return ["--default cannot be combined with clear/default/none/off", false] if persist_default
 
           switch_model(@default_model)
-          return ["runtime model reset to #{model_name}#{model_note}#{notes_note}", true]
+          return ["runtime model reset to #{model_name}#{model_note}#{thinking_note}#{notes_note}", true]
         end
 
         switch_model(arg, persist_default: persist_default)
         if persist_default
-          ["runtime model set to #{model_name}#{model_note} and default updated#{notes_note}", true]
+          ["runtime model set to #{model_name}#{model_note} and default updated#{thinking_note}#{notes_note}", true]
         else
-          ["runtime model set to #{model_name}#{model_note}#{notes_note}", true]
+          ["runtime model set to #{model_name}#{model_note}#{thinking_note}#{notes_note}", true]
         end
       end
     end

data/lib/samagotchi/session_continue.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "session"
+require_relative "session_setup"
+require_relative "session_inbox"
+require_relative "session_chain"
+require_relative "child_move"
+require_relative "archive_store"
+require_relative "recap_store"
+require_relative "bridge_client"
+require_relative "model_profile"
+require_relative "log"
+require_relative "session_manager"
+
+module Samagotchi
+  # The next link of a session chain (chi send --new --continues, web
+  # Continue →): SessionManager.continue_session runs .run. The archive,
+  # spawn, stop and wake it builds on are SessionManager's.
+  module SessionContinue
+    # A continue that can't happen (#run). reason: :continued
+    # (another session continues it already: +ids+ names it), :open_children
+    # (open children it can't move to the new link: on an older chi's
+    # worker or open in a chi REPL; +ids+ names them) or :folder_gone (its
+    # folder isn't there).
+    class Refused < StandardError
+      attr_reader :session_id, :reason, :ids
+
+      def initialize(session_id, reason, ids: [], detail: nil)
+        @session_id = session_id
+        @reason = reason
+        @ids = ids
+        super(continue_refused_message(detail))
+      end
+
+      private
+
+      def continue_refused_message(detail)
+        short = @session_id[0, 8]
+        case @reason
+        when :continued then "#{short} is continued already, by #{@ids.first[0, 8]}; continue that one (or last:#{short})"
+        when :open_children
+          "#{short} has delegates still open that can't move to the next link: #{detail}; " \
+          "then continue (or wait for them, stop them or archive them)"
+        else "#{short}'s folder #{detail} is gone"
+        end
+      end
+    end
+
+    # How long #run waits for the previous link's worker to write its
+    # recap (IdleRecap's own request timeout).
+    RECAP_WAIT = 30.0
+    # In the previous link's folder: one continue of a session at a time.
+    LOCK = "continue.lock"
+    # How often a last:<id> continue looks again when another continue
+    # moved the chain's end while it waited for the lock.
+    TRIES = 3
+
+    # Start the next link of a chain: a new session that continues
+    # +id_or_ref+ (Session#continues) in its folder, on its model (the name
+    # it was typed as, so an alias holds) and with its own setup (SessionSetup),
+    # starting with a context note from chi: the link and the previous
+    # link's recap (SessionChain.note_text). The previous link is archived
+    # first, with its finished delegates (archive_session's rules: a turn
+    # running, a prompt queued or the step-limit question refuse; an idle
+    # worker is stopped), so a refusal starts nothing. Its open delegates
+    # (running, waiting, live, an unreported reply, at any depth below them)
+    # move to the new link instead (ChildMove): their reports reach it.
+    # Before that its live worker is asked for a recap and given up to
+    # +recap_wait+ seconds to write it.
+    # One continue of a session at a time (a lock in its folder): a double
+    # click finds the first one's link and is refused; a last:<id> one
+    # follows the chain to its new end instead.
+    # @param id_or_ref [String] an id, a prefix, or last:<id> (SessionChain.resolve)
+    # @param prompt [String, nil] its first message (nil: it starts idle)
+    # @param title [String, nil] what the lists show before the first turn;
+    #   by default the prompt, else the previous link's preview
+    # @return [Session] the new link (#model_warning as spawn_session's,
+    #   #moved_children: the delegates it took over)
+    # @raise [ArgumentError] no such session (Session::AmbiguousId for a prefix of several)
+    # @raise [Refused] continued already, delegates open that can't
+    #   move, or its folder is gone
+    # @raise [ArchiveRefused, OwnedByTUI] as archive_session
+    def self.run(id_or_ref, prompt: nil, title: nil, state_dir: nil, recap_wait: RECAP_WAIT, archive_wait: 5)
+      sd = state_dir || Session.default_state_dir
+      TRIES.times do |try|
+        id = SessionChain.resolve(id_or_ref, state_dir: sd)
+        result = with_lock(id, sd) do
+          follow = id_or_ref.to_s.strip.start_with?(SessionChain::LAST_PREFIX) && try < TRIES - 1
+          next :moved if follow && SessionChain.next_of(id, state_dir: sd)
+
+          run_locked(id, prompt: prompt, title: title, state_dir: sd, recap_wait: recap_wait,
+                         archive_wait: archive_wait)
+        end
+        return result unless result == :moved
+      end
+    end
+
+    private_class_method def self.with_lock(id, state_dir, &)
+      dir = Session.session_dir(id, state_dir: state_dir)
+      FileUtils.mkdir_p(dir)
+      File.open(File.join(dir, LOCK), File::RDWR | File::CREAT, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        yield
+      end
+    end
+
+    private_class_method def self.run_locked(id, prompt:, title:, state_dir:, recap_wait:, archive_wait:)
+      previous = Session.load(id, state_dir: state_dir)
+      plan = check!(previous, state_dir)
+      # archive_session's refusals that can be known now, before the wait.
+      SessionManager.archivable!(id, state_dir, except: plan.move)
+      recap_before_archive(id, state_dir, wait: recap_wait)
+      # Again: a turn sent to it during the wait may have delegated (they
+      # move too), or a delegate finished.
+      plan = move_plan!(id, state_dir)
+      already = [id, *SessionManager.descendant_ids(id, state_dir, except: plan.move)].select do |sid|
+        ArchiveStore.archived?(Session.session_dir(sid, state_dir: state_dir))
+      end
+      archive = SessionManager.archive_session(id, state_dir: state_dir, wait: archive_wait, except: plan.move)
+      archived = archive[:archived] - already
+      begin
+        spawn_continuation(previous, prompt: prompt, title: title, state_dir: state_dir, move: plan.move)
+      rescue StandardError
+        # Nothing started: the delegates go back, what this archived goes
+        # back to the lists, and a new link saved before its worker failed
+        # to spawn goes (left, it would hold the chain: "continued already",
+        # last: to it).
+        undo_move(id, state_dir, moved: plan.move)
+        begin
+          discard_failed_link(id, state_dir)
+        ensure
+          archived.each { |sid| ArchiveStore.unarchive(sid, state_dir: state_dir) }
+          wake_for_rings(id, state_dir) unless plan.move.empty?
+        end
+        raise
+      end
+    end
+
+    # The delegates a failed #run moved, or began to (its
+    # intent names them), go back to +id+.
+    private_class_method def self.undo_move(id, state_dir, moved:)
+      link = SessionChain.next_of(id, state_dir: state_dir) or return
+      ids = ChildMove.read_intent(link, state_dir: state_dir)&.ids || moved
+      ChildMove.apply(ids, from: link, to: id, state_dir: state_dir, undo: true)
+      ChildMove.clear_intent(link, state_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:worker, "continue_undo_move_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
+    # The link a failed #run saved (no other continues +id+:
+    # check! made sure under the lock): its worker stopped if one
+    # started, then the rings a moved delegate wrote into it just before
+    # the undo go back to +id+, then the link goes. A worker that outlives
+    # the stop is raised (SessionManager::DeleteRefused): the link stays,
+    # and the caller hears it.
+    private_class_method def self.discard_failed_link(id, state_dir)
+      orphan = SessionChain.next_of(id, state_dir: state_dir) or return
+      if SessionManager.refuse_tui!(orphan, state_dir: state_dir) &&
+         !SessionManager.stop_session(orphan, state_dir: state_dir, wait: 10)
+        raise SessionManager::DeleteRefused.new(orphan, :still_stopping)
+      end
+
+      ChildMove.return_rings(from: orphan, to: id, state_dir: state_dir)
+      SessionManager.delete_session(orphan, state_dir: state_dir)
+    rescue SessionManager::DeleteRefused
+      raise
+    rescue StandardError => e
+      Log.warn(:worker, "continue_cleanup_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
+    # A failed continue's previous link, back in the lists, with rings that
+    # came in meanwhile: wake it for them, as the ring's own wake would have.
+    private_class_method def self.wake_for_rings(id, state_dir)
+      return if SessionInbox.find_ring_files(Session.session_dir(id, state_dir: state_dir)).empty?
+
+      SessionManager.wake_for_report(id, state_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:worker, "continue_wake_failed", sid: id, error: e.class.name, msg: e.message)
+    end
+
+    # The new link, holding off any worker but its own (ChildMove.starting?)
+    # while +move+ goes to it.
+    private_class_method def self.spawn_continuation(previous, prompt:, title:, state_dir:, move:)
+      recap = RecapStore.read(Session.session_dir(previous.id, state_dir: state_dir))
+      start = prompt.to_s.strip.empty? ? nil : prompt
+      title = previous.first_preview if title.to_s.strip.empty? && start.nil?
+      before_spawn = lambda do |link|
+        ChildMove.mark_starting(link.id, state_dir: state_dir)
+        ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
+      end
+      link = SessionManager.spawn_session(
+        prompt: start, title: title, working_directory: previous.working_directory,
+        model_name: previous.model_typed || previous.model_name, setup: SessionSetup.of(previous),
+        continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
+        note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn
+      )
+      link.moved_children = move
+      link
+    end
+
+    # The refusals that come before anything changes: continued already (no
+    # forks in a chain), an open delegate that can't move to the new link
+    # (ChildMove.plan), the folder gone (the worker would run elsewhere), a
+    # model whose host config.yml no longer has.
+    # @return [ChildMove::Plan]
+    # @raise [Refused, ModelProfile::MissingModel]
+    private_class_method def self.check!(previous, state_dir)
+      if (following = SessionChain.next_of(previous.id, state_dir: state_dir))
+        raise Refused.new(previous.id, :continued, ids: [following])
+      end
+
+      plan = move_plan!(previous.id, state_dir)
+      # Its model's host, as SessionManager.spawn_session checks it: before
+      # the archive stops the previous link's worker.
+      ModelProfile.check_host!(ModelProfile.required_model_name(previous.model_typed || previous.model_name))
+      dir = previous.working_directory.to_s
+      raise Refused.new(previous.id, :folder_gone, detail: dir) unless File.directory?(dir)
+
+      plan
+    end
+
+    # A child still open below a session (#open_children); why: running,
+    # waiting, live, unreported reply, or why it can't move (ChildMove).
+    OpenChild = Data.define(:id, :short_id, :why)
+
+    # The delegates a continue of +id+ moves (ChildMove.plan).
+    # @return [ChildMove::Plan]
+    # @raise [Refused] for open ones it can't move
+    private_class_method def self.move_plan!(id, state_dir)
+      plan = ChildMove.plan(id, open: open_children(id, state_dir), state_dir: state_dir)
+      return plan if plan.refuse.empty?
+
+      raise Refused.new(id, :open_children, ids: plan.refuse.map(&:id),
+                                                    detail: plan.refuse.map { |c| "#{c.short_id} (#{c.why})" }.join(", "))
+    end
+
+    # The unarchived children, at any depth (the archive's cascade), of the
+    # session still running, waiting for an answer, with a live worker, or
+    # (a delegate) with a reply its parent wasn't given (ChildrenStatus).
+    # @return [Array<OpenChild>]
+    def self.open_children(id, state_dir)
+      require_relative "children_status"
+      nodes = [id, *SessionManager.descendant_ids(id, state_dir)]
+      nodes.flat_map { |node| ChildrenStatus.of(node, state_dir: state_dir) }.uniq(&:id).filter_map do |child|
+        why = if %w[waiting running].include?(child.state) then child.state
+              elsif child.live then "live"
+              elsif child.delegate && child.last_reply && !child.reported then "unreported reply"
+              end
+        why && OpenChild.new(id: child.id, short_id: child.short_id, why: why)
+      end
+    end
+
+    # Ask the session's live worker for a recap now (Bridge POST /recap:
+    # IdleRecap#request_now) and wait, up to +wait+ seconds, for recap.json
+    # to change. A worker that is gone wrote its recap when it left; one
+    # that has nothing new to say, too short a conversation, or recaps off
+    # answers at once. Best effort: the continue goes on without.
+    private_class_method def self.recap_before_archive(id, state_dir, wait:)
+      return unless SessionManager.worker_live?(id, state_dir: state_dir)
+
+      dir = Session.session_dir(id, state_dir: state_dir)
+      client = BridgeClient.discover(id, session_dir: dir) or return
+      before = RecapStore.read(dir)
+      reply = client.request_recap
+      asked = reply.status == 200 && reply.json.is_a?(Hash) ? reply.json["request"] : nil
+      return unless %w[started in_flight].include?(asked)
+
+      BridgeClient.poll(wait, interval: 0.2) { RecapStore.read(dir) != before }
+    rescue StandardError => e
+      Log.info(:worker, "continue_recap_failed", sid: id, error: e.class.name, msg: e.message)
+      nil
+    end
+  end
+end