samagotchi 0.12.0 → 0.14.0

data/lib/samagotchi/answer_command.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative "session"
+require_relative "session_manager"
+require_relative "bridge_client"
+require_relative "reply_wait"
+require_relative "parent_report"
+require_relative "guardrails/parent_approvals"
+require_relative "cli/command"
+require_relative "cli/flags"
+require_relative "cli/parent_wait"
+
+module Samagotchi
+  # `chi answer`: answer the question a session's worker waits on (exit 3
+  # from chi send --wait), then wait for what comes next and print it the
+  # same way: the reply (0), the next question (3), still running (4). It is
+  # how a parent agent running chi as a sub-agent answers; the web and
+  # chi --attach answer the same question. See docs/sub-agent.md.
+  #
+  # An approval is the user's to allow: a parent may deny it, and allow it
+  # only "once" when guardrails.parent_approvals (config.yml) says so. It is
+  # checked here and again by the worker, which sees the answer marked as
+  # chi answer's. That guards an honest but eager parent, not a boundary:
+  # the Bridge and the localhost web take answers from any local process.
+  class AnswerCommand
+    include CLI::Command
+    include CLI::ParentWait
+
+    USAGE = <<~TEXT
+      Usage: chi answer ID --question QID (--option N|LABEL)... [--text T] [--timeout S] [--format json]
+             chi answer ID --question QID --dismiss [--timeout S] [--format json]
+        Answers the question session ID waits on (chi send --wait exits 3
+        with it), then waits for what comes next and prints it as chi send
+        --wait does.
+        --question QID  the question's id (chi send --wait prints it); a
+                        question no longer open is not answered
+        --option N|LABEL
+                        an option, by number (1-based) or label; repeat
+                        on a multi-select question
+        --text T        free text, where the question allows it; with an
+                        approval, the reason for a Deny (text alone denies)
+        --dismiss       leave it unanswered: chi does nothing it asked
+                        about and finishes its reply
+        --timeout S     give up waiting after S seconds (exit 4)
+        --format json   one JSON object on stdout (see chi send --help)
+        An approval (a guardrail's ask) can be denied here: deny it, and
+        tell your user; allowing it is the user's. With
+        guardrails.parent_approvals: once, "Allow once" is let through.
+        Exit: 0 answered, 1 failed, refused or the worker is gone, 2
+        usage or an option the question doesn't offer, 3 a question waits,
+        4 still running (--timeout), 130 Ctrl-C.
+    TEXT
+
+    FLAGS = CLI::Flags.new(help: CLI::Command::HELP_WORDS) do |f|
+      f.value "--question"
+      f.value "--option", key: :options, repeat: true
+      f.value "--text"
+      f.switch "--dismiss"
+      f.value "--timeout"
+      f.value "--format"
+    end
+
+    def initialize(argv, stdout: $stdout, stderr: $stderr, state_dir: nil)
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+      @state_dir = state_dir || Session.default_state_dir
+    end
+
+    private
+
+    def command_name = "chi answer"
+
+    def parse
+      parsed = parse_flags(FLAGS, @argv, options: [])
+      return parsed if parsed.is_a?(Integer)
+
+      options = parsed.options
+      return usage_error("give one session id") unless parsed.args.size == 1
+      return usage_error("--question QID is required (chi send --wait prints it)") if options[:question].to_s.strip.empty?
+      if options[:dismiss]
+        return usage_error("--dismiss takes no --option or --text") if !options[:options].empty? || options[:text]
+      elsif options[:options].empty? && options[:text].nil?
+        return usage_error("nothing to answer with: --option, --text or --dismiss")
+      end
+      return usage_error("--format takes text or json") if options[:format] && !FORMATS.include?(options[:format])
+      if options[:timeout]
+        options[:timeout] = Float(options[:timeout], exception: false)
+        return usage_error("--timeout takes seconds") unless options[:timeout]&.positive?
+      end
+      options.merge(id: parsed.args.first)
+    end
+
+    # Answer, then wait for what comes next.
+    # @return [Integer] the exit status
+    def run_parsed(options)
+      id = resolve(options[:id]) or return 1
+      qid = options[:question].strip
+      session = Session.load(id, state_dir: @state_dir)
+      pending = session.pending_question
+      # Taken before the answer goes in, with the question answered as the
+      # one already reported: the file keeps it until the turn thread
+      # wakes, and it must not come back as exit 3.
+      cursor = ReplyWait.newest_reply(id, state_dir: @state_dir)
+      baseline = ReplyWait.baseline_of(session, question_id: qid)
+
+      if pending && pending[:id].to_s == qid
+        selected = selection(pending, options) or return @selection_status
+        refusal = approval_refusal(pending, selected, id)
+        return failure(refusal) if refusal
+
+        posted = post(id, qid, selected, options)
+        return posted if posted.is_a?(Integer)
+      elsif session.status != Session::STATUS_RUNNING
+        return failure("no question #{qid} waits in #{id[0, 8]}; nothing to answer")
+      else
+        not_open(qid)
+      end
+      # Answered here, or no longer open (answered elsewhere, or a newer
+      # question): what comes next either way.
+      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout])
+    end
+
+    # The labels to send. A number is an option's place (1-based); an
+    # exact label wins over a number.
+    # @return [Array<String>, nil] nil after a usage error
+    def selection(pending, options)
+      offered = Array(pending[:options]).map(&:to_s)
+      labels = options[:options].map do |given|
+        next given if offered.include?(given)
+
+        index = Integer(given, exception: false)
+        next offered[index - 1] if index&.between?(1, offered.size)
+
+        listed = offered.each_with_index.map { |label, i| "#{i + 1}. #{label}" }.join(", ")
+        @selection_status = usage_failure("no option #{given}; the options: #{listed}")
+        return nil
+      end
+      if labels.uniq.size > 1 && !pending[:multi_select]
+        @selection_status = usage_failure("one option only: the question is single-select")
+        return nil
+      end
+      labels.uniq
+    end
+
+    # Why a parent may not give this answer to an approval, or nil
+    # (Guardrails::ParentApprovals, with this process's config.yml). A
+    # Deny, text alone or a dismissal always passes: each one denies. The
+    # worker checks it again with its own config.
+    def approval_refusal(pending, selected, id)
+      offered = Array(pending[:options]).map(&:to_s)
+      indices = selected.map { |label| offered.index(label) }
+      reason = Guardrails::ParentApprovals.refusal(pending, indices, setting: Guardrails::ParentApprovals.setting)
+      reason && Guardrails::ParentApprovals.message(reason)
+    end
+
+    # Post the answer (or the dismissal) to the live worker's Bridge.
+    # @return [Integer, nil] an exit status when it didn't go in; nil to
+    #   wait (it went in, or the question was no longer open: 409)
+    def post(id, qid, selected, options)
+      client = BridgeClient.discover(id, session_dir: Session.session_dir(id, state_dir: @state_dir))
+      return failure(worker_gone(id)) unless client
+
+      reply = nil
+      2.times do
+        reply = if options[:dismiss]
+                  client.dismiss_question(id: qid)
+                else
+                  client.answer(id: qid, selected: selected, freeform: options[:text],
+                                client_id: Guardrails::ParentApprovals::CLIENT_ID)
+                end
+        break unless reply.status == 408
+      end
+
+      case reply.status
+      when 200 then nil
+      when 409 then not_open(qid)
+      when 400 then usage_failure(reply.json&.dig("detail") || "the worker refused the answer")
+      # The worker's own guardrails.parent_approvals refused the allow.
+      when 403 then failure(reply.json&.dig("detail") || "the worker refused the allow: deny it, and tell your user")
+      when 408 then failure("the worker did not take the answer in time; the question is still open: try again")
+      when 404
+        return failure(worker_gone(id)) if reply.json&.dig("error") == "unknown_session"
+
+        cant = options[:dismiss] ? "dismiss a question" : "take an answer"
+        failure(BridgeClient.stale_worker_message(id, cant: cant))
+      else failure("the worker answered #{reply.status}: #{reply.json&.dig("detail") || reply.body}")
+      end
+    rescue Errno::ETIMEDOUT
+      failure("the worker did not take the answer in time; the question is still open: try again")
+    rescue SystemCallError, IOError, SocketError
+      failure(worker_gone(id))
+    end
+
+    # The question was answered elsewhere (the web first), or another one
+    # waits now: said, then what comes next is waited for.
+    # @return [nil]
+    def not_open(qid)
+      error_line("#{command_name}: question #{qid} is no longer open; not answered here, waiting for what comes next")
+      nil
+    end
+
+    def worker_gone(id)
+      "the worker is gone and the question with it; send the task again: chi send --wait -m \"…\" #{id}"
+    end
+
+    # @return [Integer] 1, after the line
+    def failure(line)
+      error_line("#{command_name}: #{line}")
+      1
+    end
+
+    # The Bridge refused the answer itself (an option not offered, two on a
+    # single-select question): a usage error, the question still open.
+    def usage_failure(line)
+      error_line("#{command_name}: #{line}")
+      CLI::Exit::USAGE
+    end
+  end
+end

data/lib/samagotchi/bridge/card_store.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "json"
+require "fileutils"
+require_relative "../atomic_file"
 require_relative "../events"
 
 module Samagotchi
@@ -20,32 +23,70 @@ module Samagotchi
     # A card with an earlier card's id replaces it where it was. Each entry
     # says where it belongs as the recap does: +turns_since+, the turns
     # completed after it (after its own turn for a card shown during one),
-    # and +current+ for a card of the turn running now. Turns count from
-    # this worker's start; the ones before it are in no entry. A card that
+    # and +current+ for a card of the turn running now. A card that
     # isn't the turn's but comes while one runs (an anytime command's, such
     # as /btw) goes after that turn: its prompt is already in the history.
     # A failed turn leaves no prompt, so its cards stay before the next one.
+    #
+    # Notices (hook notices, load warnings, "asking again" rows) and cards
+    # (with questions) are capped apart, +capacity+ each, so a burst of
+    # notices can't push out a card. An open question (an approval too) is
+    # never pushed out: the oldest other card or answered question goes.
+    #
+    # With a +path+ (the Bridge's: FILE in the session's folder) the store
+    # saves its entries and turn count there on each change, and a later
+    # worker's store starts from them, so a turn's cards and notices outlive
+    # the worker that showed them; the web reads the file (.saved) for a
+    # session no worker runs. Turns count on from the saved count: the
+    # placement is relative (turns since), so only the turns after an entry
+    # matter. The load warnings stay the worker's own (each start announces
+    # its own), and a question still open when the worker went waits for no
+    # one: neither is saved or seeded. Same caps as in memory. An entry from
+    # an earlier worker lists with +earlier+: true (an attached TUI's resync
+    # onto a new worker doesn't print those again).
     class CardStore
       CAPACITY = 20
+      NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry].freeze
+      FILE = "cards.json"
+      # The events after which the file is written again: the ones that
+      # change an entry or the turn count.
+      SAVED_ON = (%i[card hook_notice empty_answer_retry question_requested question_answered question_cancelled
+                     turn_failed] + Events::TURN_KEPT).freeze
+
+      # What a session's saved file lists, as a store started from it lists
+      # (no turn running): the web's cards for a session no worker runs.
+      # @param session_dir [String]
+      # @return [Array<Hash>] [] without a readable file
+      def self.saved(session_dir)
+        new(path: File.join(session_dir, FILE)).list
+      end
 
-      def initialize(capacity: CAPACITY)
+      # @param path [String, nil] the file the entries are saved in and
+      #   started from; nil keeps them in memory only
+      def initialize(capacity: CAPACITY, path: nil)
         @capacity = capacity
+        @path = path
         @mutex = Mutex.new
         @entries = []
         @turns_done = 0
         @running = false
         @iteration = nil
         @calls = 0
+        seed
       end
 
       def call(event)
-        @mutex.synchronize { fold(event) }
+        @mutex.synchronize do
+          fold(event)
+          save if SAVED_ON.include?(event[:type])
+        end
       rescue StandardError
         nil # never break the running turn
       end
 
       # @return [Array<Hash>] oldest first: the card's (or notice's) fields
-      #   plus turns_since: and current:, and during: true for a card that
+      #   plus turns_since: and current:, earlier: true for one an earlier
+      #   worker saved, and during: true for a card that
       #   came while the running turn runs but isn't that turn's (it goes
       #   after the running turn's prompt)
       def list
@@ -63,6 +104,42 @@ module Samagotchi
 
       private
 
+      def save
+        return unless @path
+
+        entries = @entries.reject { |entry| entry[:type] == :guardrail_warning }
+        # A session that never showed one gets no file (the turn count
+        # only places entries relative to each other).
+        return if entries.empty? && !File.exist?(@path)
+
+        FileUtils.mkdir_p(File.dirname(@path))
+        AtomicFile.write(@path, JSON.generate({ "version" => 1, "turns" => @turns_done, "entries" => entries }))
+      rescue StandardError
+        nil # a card that can't be saved still shows live
+      end
+
+      # The entries an earlier worker saved (a missing or broken file:
+      # none), their types as symbols again; a card that came during that
+      # worker's last turn stays where it was, as after a failed turn.
+      def seed
+        return unless @path && File.file?(@path)
+
+        data = JSON.parse(File.read(@path), symbolize_names: true)
+        return unless data.is_a?(Hash) && data[:turns].is_a?(Integer) && data[:entries].is_a?(Array)
+
+        @turns_done = data[:turns]
+        @entries = data[:entries].filter_map do |entry|
+          next unless entry.is_a?(Hash) && entry[:type].is_a?(String) && entry[:turns].is_a?(Integer)
+
+          entry = entry.merge(type: entry[:type].to_sym, earlier: true)
+          entry unless entry[:type] == :guardrail_warning || open_question?(entry)
+        end
+        settle_during(after_turn: false)
+      rescue StandardError
+        @turns_done = 0
+        @entries = []
+      end
+
       def fold(event)
         case event[:type]
         when :turn_started
@@ -144,7 +221,18 @@ module Samagotchi
 
       def push(entry)
         @entries << entry
-        @entries.shift while @entries.size > @capacity
+        notice = notice?(entry)
+        kind = @entries.select { |e| notice?(e) == notice }
+        return if kind.size <= @capacity
+
+        evict = kind.find { |e| !open_question?(e) }
+        @entries.delete_at(@entries.index { |e| e.equal?(evict) }) if evict
+      end
+
+      def notice?(entry) = NOTICE_TYPES.include?(entry[:type])
+
+      def open_question?(entry)
+        entry[:type] == :question && !entry.key?(:answer) && !entry[:cancelled]
       end
     end
   end

data/lib/samagotchi/bridge.rb

@@ -18,6 +18,7 @@ require_relative "bridge/sse_writer"
 require_relative "bridge/turn_accumulator"
 require_relative "session"
 require_relative "engine"
+require_relative "guardrails/parent_approvals"
 require_relative "session_commands"
 require_relative "image_store"
 require_relative "log"
@@ -94,7 +95,9 @@ module Samagotchi
       @port = port
       @ring = RingBuffer.new(capacity: ring_capacity)
       @accumulator = TurnAccumulator.new
-      @cards = CardStore.new
+      # Saved in the session's folder: a later worker, and the web without
+      # one, show the cards where they were.
+      @cards = CardStore.new(path: File.join(session_dir, CardStore::FILE))
       @pending_card = PendingCard.new(session_dir)
       @heartbeat_interval = heartbeat_interval
       @epoch = SecureRandom.hex(4)
@@ -496,6 +499,10 @@ module Samagotchi
       qid = fetched(parsed, "id")
       selected = fetched(parsed, "selected")
       freeform = fetched(parsed, "freeform")
+      # chi answer's marker: a parent agent, held to this worker's
+      # guardrails.parent_approvals (QuestionDesk::Refused). Not a boundary:
+      # any local process may post here, with or without it.
+      client_id = fetched(parsed, "client_id")
       if qid.to_s.strip.empty?
         return [{ "Allow" => "POST" }, 400, { error: "missing_fields", detail: "id required" }]
       end
@@ -504,11 +511,15 @@ module Samagotchi
       return deadline_passed("answer") if expired?("answer_expired", deadline, sid: session_id, id: qid)
 
       begin
-        result = @engine.answer_question(id: qid, selected: selected, freeform: freeform)
+        result = @engine.answer_question(id: qid, selected: selected, freeform: freeform, client_id: client_id)
         [{}, 200, { status: "answered", session_id: session_id, answer: result }]
       rescue Engine::QuestionNotPending => e
         # Another client answered first, or the question was cancelled.
         [{}, 409, { error: "question_not_pending", detail: e.message }]
+      rescue QuestionDesk::Refused => e
+        Log.info(:bridge, "parent_approval_refused", sid: session_id, id: qid, reason: e.reason)
+        [{}, 403, { error: "parent_approval_refused",
+                    detail: Guardrails::ParentApprovals.message(e.reason) }]
       rescue ArgumentError => e
         [{}, 400, { error: "invalid_answer", detail: e.message }]
       end
@@ -888,6 +899,7 @@ module Samagotchi
       202 => "Accepted",
       204 => "No Content",
       400 => "Bad Request",
+      403 => "Forbidden",
       404 => "Not Found",
       409 => "Conflict",
       500 => "Internal Server Error",

data/lib/samagotchi/bridge_client.rb

@@ -108,10 +108,15 @@ module Samagotchi
 
     # POST /session/:id/answer. 200 = recorded, 409 = another client answered
     # first (or the question is gone), 400 = invalid selection, 408
-    # deadline_passed = read too late and dropped (see DEADLINE_SHARE).
+    # deadline_passed = read too late and dropped (see DEADLINE_SHARE), 403
+    # parent_approval_refused = a parent's allow (client_id cli:answer)
+    # beyond the worker's guardrails.parent_approvals.
+    # @param client_id [String, nil] who answers (chi answer marks its own)
     # @return [Response]
-    def answer(id:, selected:, freeform: nil)
-      post("answer", { id: id, selected: selected, freeform: freeform, deadline: deadline }, read_body: true)
+    def answer(id:, selected:, freeform: nil, client_id: nil)
+      body = { id: id, selected: selected, freeform: freeform, deadline: deadline }
+      body[:client_id] = client_id if client_id
+      post("answer", body, read_body: true)
     end
 
     # POST /session/:id/question/dismiss: leave the question unanswered.

data/lib/samagotchi/bundle_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "cli/flags"
+require_relative "cli/exit"
 require_relative "memory_bundle"
 
 module Samagotchi
@@ -109,7 +110,7 @@ module Samagotchi
       when "build" then build(@argv[1..])
       else
         @stderr.puts "Unknown bundle subcommand: #{sub}. Use: install, upgrade, uninstall, status, diff, list, build"
-        return 2
+        return CLI::Exit::USAGE
       end
     end
 
@@ -124,7 +125,7 @@ module Samagotchi
       force = opts.fetch(:force, false)
       if source.nil? || source.empty?
         @stderr.puts "Usage: chi bundle install <source> [--scope system|project] [--force]"
-        return 2
+        return CLI::Exit::USAGE
       end
       expanded_source = expand_source(source)
       if Samagotchi::MemoryBundle::Profile.shipped_meta?(expanded_source)
@@ -148,7 +149,7 @@ module Samagotchi
       agent = opts[:agent]
       if source.nil? || source.empty?
         @stderr.puts "Usage: chi bundle upgrade <source> [--scope system|project] [--force] [--dry-run]"
-        return 2
+        return CLI::Exit::USAGE
       end
       expanded_source = expand_source(source)
       if Samagotchi::MemoryBundle::Profile.shipped_meta?(expanded_source)
@@ -217,7 +218,11 @@ module Samagotchi
 
     # An upgrade that kept edited files: launch an agent to merge them
     # (--agent, or yes on a terminal), or say how to take the bundle's.
-    # @return [Integer] 0 resolved, 2 kept the edits
+    # An upgrade that kept edited files exits 2, as a usage error does
+    # (scripts already read it so): not CLI::Exit::USAGE by meaning.
+    CONFLICTS_KEPT = 2
+
+    # @return [Integer] 0 resolved, CONFLICTS_KEPT kept the edits
     def upgrade_conflicts(installer, bundle_name, expanded_source, agent)
       @stdout.puts "\n#{installer.conflicts.size} conflict(s) need resolution."
       installer.conflicts.each { |k, _| @stdout.puts "  conflict: #{k}" }
@@ -227,13 +232,13 @@ module Samagotchi
                  ans && ans.strip.downcase.start_with?("y")
                elsif agent.nil?
                  @stdout.puts "Non-interactive terminal: kept your edits in the file(s) above; the rest is upgraded. Re-run with --force to take the bundle's version, or --agent in a TTY to merge."
-                 return 2
+                 return CONFLICTS_KEPT
                else
                  agent
                end
       unless launch
         @stdout.puts "Kept your edits in the file(s) above; the rest is upgraded. chi bundle diff #{bundle_name} FILE shows the base; re-run with --force to take the bundle's version."
-        return 2
+        return CONFLICTS_KEPT
       end
 
       prompt = build_conflict_prompt(bundle_name, installer.conflicts, expanded_source)
@@ -258,7 +263,7 @@ module Samagotchi
       force = opts.fetch(:force, false)
       if bundle_name.nil? || bundle_name.empty?
         @stderr.puts "Usage: chi bundle uninstall <bundle> [--scope system|project] [--force]"
-        return 2
+        return CLI::Exit::USAGE
       end
       data = Samagotchi::MemoryBundle::Provenance.new(name: bundle_name).read
       return uninstall_profile(bundle_name, force: force) if Samagotchi::MemoryBundle::Profile.installed_meta?(bundle_name, data)
@@ -355,6 +360,8 @@ module Samagotchi
             exists = File.exist?(hook_path) ? "ok" : "missing"
             @stdout.puts "    #{hk}: event=#{event} on_error=#{on_error} priority=#{prio} [#{exists}]"
           end
+          @stdout.puts "    requires_chi: #{st[:provenance][:requires_chi]}" if st[:hooks_requires_failure]
+          @stdout.puts "    not loaded: #{st[:hooks_requires_failure]}" if st[:hooks_requires_failure]
         end
         if (plugin = st[:plugin])
           note = plugin[:state] == "modified" ? " (edited after install: not loaded; reinstall the bundle)" : ""
@@ -379,6 +386,7 @@ module Samagotchi
           hook_info = hooks_count > 0 ? " hooks=#{hooks_count}" : ""
           plugin = st[:plugin]
           mods += 1 if plugin && (plugin[:state] != "ok" || plugin[:requires_failure])
+          mods += 1 if st[:hooks_requires_failure]
           plugin_info = plugin ? " plugin=#{plugin[:file]}" : ""
           includes = st[:provenance][:includes]
           includes_info = includes ? " includes=#{includes.join(",")}" : ""
@@ -393,7 +401,7 @@ module Samagotchi
       bname = args[0]
       file_arg = args[1]
       if bname.nil? || bname.empty?
-        @stderr.puts "Usage: chi bundle diff <bundle> [file]"; return 2
+        @stderr.puts "Usage: chi bundle diff <bundle> [file]"; return CLI::Exit::USAGE
       end
       prov = Samagotchi::MemoryBundle::Provenance.new(name: bname)
       data = prov.read
@@ -534,7 +542,7 @@ module Samagotchi
       # Validate scope if given
       if scope && !%w[system project].include?(scope.to_s.strip.downcase)
         @stderr.puts "Invalid scope '#{scope}', expected system or project"
-        return 2
+        return CLI::Exit::USAGE
       end
       begin
         builder = Samagotchi::MemoryBundle::Builder.new(
@@ -573,7 +581,7 @@ module Samagotchi
       end
       if parsed.error
         @stderr.puts "Unknown bundle #{sub} flag: #{parsed.error.arg}"
-        return 2
+        return CLI::Exit::USAGE
       end
       parsed
     end

data/lib/samagotchi/bundles/check-in/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: check-in
-version: 0.1.3
+version: 0.2.0
 scope: system
 description: "Checks on a long turn: after N tool calls with no answer, a card asks the user (Nudge / Keep going / Stop), or the model is nudged to say what it has found"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:c5aa4c49989723ec2370184cee36f4c8515d9df818b2c45422a5efb6c4ba31a7
+  sha256: sha256:0a5ba60962206b3ec90bbaa0934a7284416aef495df8a70391d9ea47f7eb9ec1
 requires_chi: ">= 0.3.0"