samagotchi 0.122.0 → 0.124.0

data/lib/samagotchi/toolkit_suggest.rb

@@ -2,14 +2,19 @@
 
 require "json"
 
+require_relative "cancellation_controller"
+require_relative "log"
 require_relative "message_time"
 require_relative "steer"
 require_relative "system_one/question"
+require_relative "toolkit"
 
 module Samagotchi
-  # The first-prompt toolkit classifier and its append-only audit record.
-  # The Engine prepares a Snapshot on its turn thread; #ask only sees that
-  # copy, so the question cannot change the running session or tool registry.
+  # The first-prompt toolkit classifier and its append-only record.
+  # The Engine prepares a Snapshot on its turn thread; #judge only sees that
+  # copy, so the question cannot change the running session or tool
+  # registry. On mode's turn applies the answer itself (Pending#wait,
+  # ToolkitBinding#suggest).
   class ToolkitSuggest
     FILE = "toolkit_suggestions.jsonl"
     QUESTION_ID = "toolkit"
@@ -24,6 +29,10 @@ module Samagotchi
     # built-ins registered when the ask started.
     Snapshot = Data.define(:session_id, :turn_number, :default, :candidates, :core_tools, :state)
     Suggestion = Data.define(:kit, :raw, :confidence, :decided)
+    # One ask's outcome: its Suggestion, what on mode would do with it
+    # (suggested, default, defer, below_threshold, invalid, no_judgment)
+    # and its log line's fields.
+    Judged = Data.define(:suggestion, :would, :fields)
 
     # The candidates with classifier descriptions, excluding the configured
     # default, the participants' review boundary, the defer sentinel, and a
@@ -56,8 +65,8 @@ module Samagotchi
       [question, { project: project.to_s, prompt: prompt.to_s[0, PROMPT_MAX] }]
     end
 
-    # The single turn eligibility predicate shared by audit and future on
-    # mode. A later prompt is eligible only inside an undecided defer window.
+    # The single turn eligibility predicate shared by audit and on mode.
+    # A later prompt is eligible only inside an undecided defer window.
     # +candidate_count+ and +last_suggestion+ may be callables: they are
     # read only once the session's own clauses pass (the kits read memory
     # files; the suggestion log is read whole), the log only on the defer
@@ -70,7 +79,7 @@ module Samagotchi
       return false if value(candidate_count).to_i < 2
 
       messages = Array(session.messages)
-      return true unless messages.any? { |message| field(message, :role).to_s == "model" }
+      return true unless model_reply?(messages)
       return false unless field(value(last_suggestion), :raw) == "undecided"
 
       current_turn_number = turn_number(messages)
@@ -108,15 +117,27 @@ module Samagotchi
       end
     end
 
-    # Runs one already-prepared ask, then appends its raw pick, what on mode
-    # would have done, and every offered kit's #rules (the default's too),
-    # so the report can tell a narrower kit that would also have covered
-    # the turn. A missing judgment is recorded too.
-    def self.ask(client:, log:, snapshot:, threshold:)
+    # Runs one already-prepared ask and appends its line (audit's thread).
+    # @return [Suggestion]
+    def self.ask(client:, log:, snapshot:, threshold:, cancel_controller: nil)
+      judged = judge(client: client, snapshot: snapshot, threshold: threshold, cancel_controller: cancel_controller)
+      record(log, judged)
+      judged.suggestion
+    end
+
+    # Runs one already-prepared ask: its raw pick, what on mode would do
+    # with it, and the log line's fields (every offered kit's #rules, the
+    # default's too, so the report can tell a narrower kit that would also
+    # have covered the turn). A missing judgment (Client#ask's nil) is a
+    # Judged too, would "no_judgment".
+    # @raise [LLM::RequestCancelled] the turn stopped while it was asked
+    # @return [Judged]
+    def self.judge(client:, snapshot:, threshold:, cancel_controller: nil)
       question, = question(default: Toolkit.new(name: snapshot.default.name),
                            kits: snapshot.candidates.to_h { |candidate| [candidate.name, kit_for(candidate)] },
                            project: snapshot.state.fetch(:project), prompt: snapshot.state.fetch(:prompt))
-      answer = client.ask(state: snapshot.state, questions: { QUESTION_ID => question })&.fetch(QUESTION_ID, nil)
+      answer = client.ask(state: snapshot.state, questions: { QUESTION_ID => question },
+                          cancel_controller: cancel_controller)&.fetch(QUESTION_ID, nil)
       raw = answer&.choice
       candidate_name = raw.to_s.delete_prefix("kit:")
       candidate = snapshot.candidates.find { |item| item.name == candidate_name } if raw.to_s.start_with?("kit:")
@@ -140,7 +161,7 @@ module Samagotchi
               else
                 "suggested"
               end
-      log.entry("suggestion", {
+      fields = {
         session_id: snapshot.session_id,
         turn_number: snapshot.turn_number,
         default_kit: snapshot.default.name,
@@ -151,8 +172,153 @@ module Samagotchi
         would: would,
         core_tools: snapshot.core_tools,
         kits: [snapshot.default, *snapshot.candidates].to_h { |kit| [kit.name, kit.rules] }
-      })
-      Suggestion.new(kit: selected, raw: raw, confidence: confidence, decided: !!decided)
+      }
+      Judged.new(suggestion: Suggestion.new(kit: selected, raw: raw, confidence: confidence, decided: !!decided),
+                 would: would, fields: fields)
+    end
+
+    # One line in the suggestion log. +did+ (on mode only) is what the
+    # turn did with it: suggested (the session switched), default, defer,
+    # chosen (the user picked a toolkit first), timeout or canceled (the
+    # turn stopped waiting; the line is written when the ask ends).
+    def self.record(log, judged, did: nil)
+      log.entry("suggestion", did.nil? ? judged.fields : judged.fields.merge(did: did))
+    end
+
+    # Whether the session has a model reply: a later prompt's ask is the
+    # defer path, and on mode's switch applies "from this turn".
+    def self.model_reply?(messages)
+      Array(messages).any? { |message| field(message, :role).to_s == "model" }
+    end
+
+    # An ask's hand-over between its thread and the turn. Audit mode never
+    # waits (+joined+ false): the thread records its line itself. On mode's
+    # turn waits (#wait) until the answer, a Stop or the deadline (System
+    # 1's timeout from the ask's start), and records what it did with the
+    # answer (#record); a turn that stopped waiting leaves the line to the
+    # thread, which writes it with why (timeout, canceled) when the ask
+    # ends.
+    #
+    # The request watches the ask's own controller (#cancel_controller),
+    # cut only by a Stop the turn sees before it settled (#wait, #abandon
+    # :canceled): a Stop later in a turn that went on after a timeout
+    # leaves the late ask (and its timeout line) alone.
+    class Pending
+      POLL_SECONDS = 0.05
+
+      # @return [CancellationController] what the ask's request watches
+      attr_reader :cancel_controller
+
+      def initialize(log:, timeout_seconds:, joined:, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+        @log = log
+        @clock = clock
+        @deadline = clock.call + timeout_seconds.to_f
+        @joined = joined
+        @cancel_controller = CancellationController.new
+        @mutex = Mutex.new
+        @done = ConditionVariable.new
+        @finished = false
+        @recorded = false
+        @settled = false
+        @judged = nil
+        @gave_up = nil
+      end
+
+      # On the ask's thread, always (an ensure): its Judged, nil when it
+      # was cut (a Stop) or raised.
+      def finish(judged)
+        @mutex.synchronize do
+          @finished = true
+          @judged = judged
+          if !@joined
+            write(nil)
+          elsif @gave_up
+            write(@gave_up)
+          end
+          @done.broadcast
+        end
+      end
+
+      # On the turn thread: [:answered, Judged or nil] once the ask ended,
+      # [:canceled, nil] when +controller+ is cancelled (first: a Stop wins
+      # over an answer already in), [:timeout, nil] at the deadline. It
+      # waits in short slices, so a Stop is seen at once.
+      def wait(controller)
+        @mutex.synchronize do
+          loop do
+            return give_up(:canceled) if controller&.cancelled?
+            return [:answered, @judged] if @finished
+
+            remaining = @deadline - @clock.call
+            return give_up(:timeout) unless remaining.positive?
+
+            @done.wait(@mutex, [remaining, POLL_SECONDS].min)
+          end
+        end
+      end
+
+      # The answered ask's line, with what the turn did.
+      def record(did)
+        @mutex.synchronize do
+          @settled = true
+          write(did.to_s)
+        end
+      end
+
+      # The turn ended before it settled the ask (a Stop before or after
+      # the wait, a failure, an Interrupt): its line says +reason+, now or
+      # when the ask ends. Nothing once the turn settled it (#record, a
+      # timeout or Stop in #wait), so prepare_turn calls it from an ensure.
+      def abandon(reason)
+        @mutex.synchronize do
+          next if @settled
+
+          if @finished
+            @settled = true
+            write(reason.to_s)
+          else
+            give_up(reason.to_sym)
+          end
+        end
+      end
+
+      private
+
+      def give_up(reason)
+        @settled = true
+        @gave_up = reason.to_s
+        @cancel_controller.cancel!(:manual) if reason == :canceled
+        # An answer already in (a Stop wins over it): its line now.
+        write(@gave_up) if @finished
+        [reason, nil]
+      end
+
+      # Once: an ask that ended with nothing (cut, raised) has no line.
+      def write(did)
+        return if @recorded || @judged.nil?
+
+        @recorded = true
+        ToolkitSuggest.record(@log, @judged, did: did)
+      end
+    end
+
+    # The warm-up's stand-in prompt: the question (instruction + criteria)
+    # is the real one, so System 1's server has that prefix cached when
+    # the first real prompt is asked.
+    WARMUP_PROMPT = "hello"
+
+    # One ask with the real question and a stand-in prompt, its answer
+    # dropped: on mode's warm-up as an idle worker starts (Engine
+    # #warm_toolkit_suggestion!). Straight to the backend, so a failure is
+    # one info line, never Client#ask's warn, and nothing is logged as a
+    # suggestion.
+    def self.warm(client:, default:, kits:, project:)
+      question, state = question(default: default, kits: kits, project: project, prompt: WARMUP_PROMPT)
+      client.backend.ask(state: state, questions: { QUESTION_ID => question })
+      nil
+    rescue StandardError => e
+      Log.info(:toolkit, "toolkit_suggest_warmup_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      nil
     end
 
     # A resolved kit (Toolkit::Resolved) as frozen, JSON-ready rules, not

data/lib/samagotchi/tools/builtins.rb

@@ -25,6 +25,7 @@ require_relative "delegate_result"
 require_relative "ask_user_question"
 require_relative "forget_outputs"
 require_relative "../guardrails/parent_approvals"
+require_relative "../guardrails/pair_boundary"
 require_relative "../model_profile"
 
 module Samagotchi
@@ -89,7 +90,7 @@ module Samagotchi
         end,
         Execute::NAME => lambda do |call, kctx|
           Execute.call(call[:content], cwd: call[:cwd], cancelled: cancelled_proc(kctx), stop_reason: stop_reason_proc(kctx),
-                                       env: parent_env(kctx))
+                                       **participant_execute(kctx, parent_env(kctx)))
         end,
         RegisterReminder::NAME => lambda do |call, kctx|
           RegisterReminder.call(call[:content], reminder_store: kctx.reminder_store, description: call[:description],
@@ -143,6 +144,18 @@ module Samagotchi
           SESSION_REASONING_HISTORY_ENV => history }.merge(cli_model_unset(env)).merge(xdg_absolute(env))
       end
 
+      # execute's env: and on_timeout: for the running turn. A participant's
+      # turn runs without the variables whose names hold a secret
+      # (Guardrails::PairBoundary.scrubbed_env), and a command still running
+      # at the limit is killed, never handed over as a background task that
+      # would outlive their turn; the owner's turns as configured.
+      def participant_execute(kctx, env)
+        mode = kctx.respond_to?(:participant_mode) ? kctx.participant_mode : nil
+        return { env: env } unless mode
+
+        { env: env.merge(Guardrails::PairBoundary.scrubbed_env), on_timeout: :kill }
+      end
+
       # The XDG dirs set in +env+, made absolute (nothing for an unset one).
       def xdg_absolute(env = ENV)
         Paths.absolute_xdg(env: env)

data/lib/samagotchi/update_command.rb

@@ -12,6 +12,7 @@ require_relative "memory_bundle/system_bundle"
 require_relative "session"
 require_relative "version"
 require_relative "web/lan"
+require "json"
 
 module Samagotchi
   # `chi update`: brings an installed chi up to date in one go: the system
@@ -24,13 +25,15 @@ module Samagotchi
     include CLI::Command
 
     USAGE = <<~TEXT
-      Usage: chi update [--dry-run] [--no-gem] [--no-bundles] [--no-desktop]
+      Usage: chi update [--dry-run] [--to VERSION] [--json] [--no-gem] [--no-bundles] [--no-desktop]
         Updates this chi's install: the gem (from rubygems.org), then the
         system bundle, the bundles chi ships that you installed (chi bundle
         list), and the desktop helper (macOS; rebuilt only when its sources
         changed). Edited memory files are kept and reported; nothing is
         installed that isn't already, and old gem versions stay.
         --dry-run      show what would change; change nothing
+        --to VERSION   install exactly this gem version (must be newer than this chi)
+        --json         print update rows as one JSON document
         --no-gem       don't install a newer gem (config update.gem: false)
         --no-bundles   leave the shipped bundles alone (config update.bundles: false)
         --no-desktop   leave the desktop helper alone (config update.desktop: false)
@@ -44,6 +47,8 @@ module Samagotchi
     FLAGS = CLI::Flags.new(args: false) do |f|
       f.switch "-h", "--help", "help"
       f.switch "--dry-run"
+      f.value "--to"
+      f.switch "--json"
       f.switch "--no-gem"
       f.switch "--no-bundles"
       f.switch "--no-desktop"
@@ -54,11 +59,11 @@ module Samagotchi
     end
     # The switches the newer gem's update gets again (hand_over).
     HANDED_OVER = { "--no-gem" => :no_gem, "--no-bundles" => :no_bundles, "--no-desktop" => :no_desktop,
-                    "--no-register" => :no_register }.freeze
+                    "--no-register" => :no_register, "--to" => :to, "--json" => :json }.freeze
 
     # A table row. info rows (live workers, chi web) say what runs; they
     # never fail.
-    Row = Struct.new(:component, :from, :to, :status, :failed, keyword_init: true)
+    Row = Struct.new(:component, :from, :to, :status, :failed, :kept, keyword_init: true)
 
     # What a row says after a change, and in a dry run.
     VERBS = { update: ["updated", "would update"], install: ["installed", "would install"],
@@ -95,6 +100,13 @@ module Samagotchi
         @stdout.puts(USAGE)
         return 0
       end
+      return usage_error("invalid version #{options[:to]}") if options[:to] && !Gem::Version.correct?(options[:to])
+
+      if options[:to] && !options[:gem_from] && Gem::Version.new(options[:to]) <= Gem::Version.new(VERSION)
+        @stderr.puts("chi update: #{options[:to]} is not newer than the running chi (#{VERSION})")
+        return 1
+      end
+
       unless @gem_spec
         @stderr.puts("chi update: running from a checkout (#{InstalledGem::ROOT}): chi update updates an installed chi; " \
                      "git pull, or chi bundle upgrade NAME for one bundle")
@@ -104,9 +116,13 @@ module Samagotchi
       @dry_run = options[:dry_run]
       gem = gem_row(options)
       rows = [gem, system_bundle_row, *bundle_rows(options), desktop_row(options), *live_rows].compact
-      print_table(rows)
-      footers(options).each { |line| @stdout.puts(line) }
-      @stdout.puts(summary(rows))
+      if options[:json]
+        @stdout.puts(JSON.generate(rows.map { |row| row.to_h.merge(failed: !!row.failed, kept: row.kept || []) }))
+      else
+        print_table(rows)
+        footers(options).each { |line| @stdout.puts(line) }
+        @stdout.puts(summary(rows))
+      end
       rows.any?(&:failed) ? 1 : 0
     end
 
@@ -133,22 +149,32 @@ module Samagotchi
         row.to = VERSION
         return done(row, :update)
       end
-      if (why = off(options, "gem"))
-        return skipped(row, why)
-      end
-      return skipped(row, "under Bundler: bundle update samagotchi") if @bundler
+      why = off(options, "gem") || ("under Bundler: bundle update samagotchi" if @bundler)
+      # --to asks for that exact version: not installing it is a failure, not a skip.
+      return options[:to] ? failed(row, "skipped: #{why}") : skipped(row, why) if why
 
       latest = begin
-        @gem_update.latest
+        if options[:to]
+          if ENV[GemUpdate::LOCAL_ENV].to_s.empty?
+            GemUpdate::Latest.new(version: options[:to], source: "samagotchi")
+          else
+            local = @gem_update.latest
+            return failed(row, "local gem file is #{local.version}, not #{options[:to]}") unless local.version == options[:to]
+
+            local
+          end
+        else
+          @gem_update.latest
+        end
       rescue GemUpdate::Error => e
         return row.tap { |r| r.status = "couldn't check (#{e.message})" }
       end
-      return up_to_date(row) unless @gem_update.newer?(latest)
+      return up_to_date(row) unless options[:to] || @gem_update.newer?(latest)
 
       row.to = latest.version
       return done(row, :update) if @dry_run
 
-      @stdout.puts("installing samagotchi #{latest.version}…")
+      (options[:json] ? @stderr : @stdout).puts("installing samagotchi #{latest.version}…")
       output, ok = @gem_update.install(latest)
       return failed(row, output.lines.map(&:strip).reject(&:empty?).last.to_s) unless ok
 
@@ -161,7 +187,8 @@ module Samagotchi
       wrapper = InstalledGem.wrapper(@gem_spec)
       return done(row, :update, "run chi update again to sync with it") unless wrapper
 
-      passed = HANDED_OVER.select { |_, key| options[key] }.keys
+      passed = options[:to] ? ["--to", options[:to]] : []
+      passed += HANDED_OVER.except("--to").select { |_, key| options[key] }.keys
       @stdout.flush
       @exec.call([RbConfig.ruby, wrapper, "update", "--no-gem", "--gem-from", VERSION, *passed])
       done(row, :update) # only when exec is a spec's stand-in
@@ -180,7 +207,7 @@ module Samagotchi
       row = Row.new(component: "system bundle", from: result.from, to: result.to)
       case result.status
       when :installed then done(row, :install)
-      when :updated then done(row, :update, kept(result.kept, MemoryBundle::SystemBundle::BUNDLE_NAME))
+      when :updated then done(row, :update, kept(row, result.kept, MemoryBundle::SystemBundle::BUNDLE_NAME))
       when :restored then done(row, :restore).tap { |r| r.to = nil }
       when :up_to_date then up_to_date(row)
       when :newer_installed then skipped(row, "newer than this chi's #{result.to}: left").tap { |r| r.to = nil }
@@ -203,7 +230,7 @@ module Samagotchi
       row = Row.new(component: update.name, from: update.from, to: update.to)
       case update.status
       when :would_update, :updated
-        notes = [adds(update.adds), kept(update.kept, update.name), replaced(update.replaced), *update.kept_own].compact
+        notes = [adds(update.adds), kept(row, update.kept, update.name), replaced(update.replaced), *update.kept_own].compact
         done(row, :update, notes.empty? ? nil : notes.join("; "))
       when :up_to_date then up_to_date(row)
       when :skipped then skipped(row, update.note)
@@ -325,11 +352,12 @@ module Samagotchi
       members.nil? || members.empty? ? nil : "+ #{members.join(", ")}"
     end
 
-    def kept(files, bundle)
-      return nil if files.empty?
+    def kept(row, files, bundle)
+      row.kept = files.dup
+      return nil if row.kept.empty?
 
       verb = @dry_run ? "would keep" : "kept"
-      "#{verb} your edits in #{files.join(", ")}: chi bundle diff #{bundle} #{files.first}"
+      "#{verb} your edits in #{row.kept.join(", ")}: chi bundle diff #{bundle} #{row.kept.first}"
     end
 
     def replaced(files)

data/lib/samagotchi/version.rb

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