samagotchi 0.2.0

data/lib/samagotchi/bridge_client/event_stream.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module Samagotchi
+  class BridgeClient
+    # A Bridge event stream followed on a reader thread (BridgeClient#follow).
+    #
+    # Joins with `?snapshot=1`, so the first event is a `snapshot` frame, then
+    # yields each live event parsed from JSON (string keys). When the
+    # connection drops it reconnects with `Last-Event-ID`: the Bridge replays
+    # what was missed, or sends a `reset` frame carrying a fresh snapshot when
+    # it can't. Either snapshot kind means "re-render from here".
+    #
+    # When the Bridge stays unreachable through every reconnect delay, or does
+    # not serve the session (404), it yields one synthetic
+    # `{"type" => "stream_closed", "reason" => ...}` and stops. #close stops
+    # it without that event.
+    class EventStream
+      DEFAULT_RECONNECT_DELAYS = [0.1, 0.25, 0.5, 1.0, 2.0].freeze
+      HEADER_TIMEOUT = 5.0
+
+      # @return [String, nil] the id of the last frame yielded (the reconnect cursor)
+      attr_reader :last_event_id
+
+      # @param client [BridgeClient]
+      # @param snapshot [Boolean] join with a snapshot frame rather than a replay
+      # @param client_id [String, nil] names the stream, so the worker can
+      #   tell this client's stream from others' (Bridge#open_streams_except)
+      # @param reconnect_delays [Array<Float>] sleeps between failed attempts;
+      #   one more failure than there are delays gives up
+      # @yieldparam event [Hash] string-keyed event
+      def initialize(client, snapshot: true, client_id: nil, reconnect_delays: DEFAULT_RECONNECT_DELAYS, &on_event)
+        @client = client
+        params = []
+        params << ["snapshot", "1"] if snapshot
+        params << ["client_id", client_id] if client_id
+        @query = params.empty? ? "" : "?#{URI.encode_www_form(params)}"
+        @reconnect_delays = reconnect_delays
+        @on_event = on_event
+        @last_event_id = nil
+        @closed = false
+        @sock = nil
+        @mutex = Mutex.new
+      end
+
+      # @return [self]
+      def start
+        @thread = Thread.new { run }
+        self
+      end
+
+      # Stop following: closes the socket under the reader so it wakes at once.
+      # Safe to call from the event callback itself.
+      def close
+        sock = @mutex.synchronize do
+          @closed = true
+          @sock
+        end
+        begin
+          sock&.close
+        rescue IOError
+          nil
+        end
+        @thread&.join(1) unless Thread.current == @thread
+        self
+      end
+
+      def alive? = !!@thread&.alive?
+
+      # @return [Thread, nil] the reader thread, nil when it did not finish in time
+      def join(timeout = nil) = @thread&.join(timeout)
+
+      private
+
+      def run
+        failures = 0
+        until closed?
+          outcome = read_connection
+          break if closed?
+          return finish("unknown_session") if outcome == :unknown_session
+
+          if outcome == :events
+            failures = 0
+            next
+          end
+
+          failures += 1
+          return finish("unreachable") if failures > @reconnect_delays.size
+
+          sleep(@reconnect_delays[failures - 1])
+        end
+      end
+
+      # One connection: :events when it yielded any, else why it failed.
+      def read_connection
+        sock, status = @client.connect_stream(query: @query, last_event_id: @last_event_id, timeout: HEADER_TIMEOUT)
+        return :unreachable unless sock
+
+        unless attach(sock)
+          sock.close rescue nil
+          return :closed
+        end
+        return :unknown_session if status == 404
+        return :unreachable unless status == 200
+
+        yielded = false
+        parser = SSEParser.new
+        loop do
+          chunk = sock.readpartial(4096)
+          parser.feed(chunk) do |frame|
+            event = parse(frame[:data])
+            next unless event
+
+            @last_event_id = frame[:id] if frame[:id]
+            yielded = true
+            @on_event.call(event)
+          end
+        end
+      rescue EOFError, IOError, SystemCallError
+        yielded ? :events : :unreachable
+      ensure
+        detach(sock)
+      end
+
+      # Publish the socket for #close; false when already closed.
+      def attach(sock)
+        @mutex.synchronize do
+          return false if @closed
+
+          @sock = sock
+        end
+        true
+      end
+
+      def detach(sock)
+        return unless sock
+
+        @mutex.synchronize { @sock = nil if @sock.equal?(sock) }
+        sock.close rescue nil
+      end
+
+      def parse(data)
+        event = JSON.parse(data)
+        event.is_a?(Hash) ? event : nil
+      rescue JSON::ParserError
+        nil
+      end
+
+      def finish(reason)
+        @on_event.call({ "type" => "stream_closed", "reason" => reason }) unless closed?
+      end
+
+      def closed? = @mutex.synchronize { @closed }
+    end
+  end
+end

data/lib/samagotchi/bridge_client/sse_parser.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  class BridgeClient
+    # Incremental Server-Sent Events parser: feed it raw body chunks as they
+    # arrive and it yields one frame per blank-line-terminated event. Accepts
+    # CRLF or LF line ends, joins multi-line `data:` with newlines, and skips
+    # comments (the Bridge's `: ping` heartbeats) and frames without data.
+    class SSEParser
+      def initialize
+        @buffer = +""
+        reset_frame
+      end
+
+      # @param chunk [String] raw bytes from the stream
+      # @yieldparam frame [Hash] {id: String|nil, event: String|nil, data: String}
+      def feed(chunk)
+        @buffer << chunk.to_s.b
+        while (newline = @buffer.index("\n"))
+          line = @buffer.slice!(0..newline).chomp("\n").chomp("\r").force_encoding(Encoding::UTF_8)
+          if line.empty?
+            yield({ id: @id, event: @event, data: @data.join("\n") }) if @data.any?
+            reset_frame
+          else
+            field(line)
+          end
+        end
+      end
+
+      private
+
+      def field(line)
+        return if line.start_with?(":")
+
+        name, value = line.split(":", 2)
+        value = value.to_s.delete_prefix(" ")
+        case name
+        when "id" then @id = value
+        when "event" then @event = value
+        when "data" then @data << value
+        end
+      end
+
+      def reset_frame
+        @id = nil
+        @event = nil
+        @data = []
+      end
+    end
+  end
+end

data/lib/samagotchi/bridge_client.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+
+require_relative "bridge_client/sse_parser"
+require_relative "bridge_client/event_stream"
+
+module Samagotchi
+  # Client side of a session worker's Bridge: the 127.0.0.1 HTTP + SSE server
+  # each SessionManager worker runs for its Engine (see Bridge). Discovery goes
+  # through the worker's `bridge.json` sidecar in the session directory.
+  #
+  # Requests are raw one-shot HTTP/1.1 over a TCPSocket (`Connection: close`),
+  # exactly what the Bridge's minimal server expects.
+  class BridgeClient
+    HOST = "127.0.0.1"
+    SIDECAR_FILE = "bridge.json"
+    PROBE_TIMEOUT = 0.2
+    STREAM_CONNECT_ATTEMPTS = 3
+    # Seconds #stream waits for bytes before it asks `running` again.
+    STREAM_POLL = 0.5
+    # Seconds a one-shot request waits for the whole reply. Every route
+    # answers at once (a recap is only asked for); a worker that takes the
+    # request and never answers raises Errno::ETIMEDOUT, as a dead one
+    # raises Errno::ECONNREFUSED. The event stream has no such limit.
+    READ_TIMEOUT = 30
+    # Share of the read timeout a request's deadline allows (25 s of 30): the
+    # Bridge drops a turn, command, answer or dismissal it reads after the
+    # deadline, so one this client timed out on, and said did not go
+    # through, never runs when a frozen worker wakes. The rest covers the
+    # write and the reply.
+    DEADLINE_SHARE = 5 / 6r
+
+    # A Bridge reply: HTTP status code and raw body (nil when not read).
+    Response = Struct.new(:status, :body, keyword_init: true) do
+      def ok? = status == 200
+
+      # @return [Hash, nil] the body parsed as JSON, or nil when it is not
+      def json
+        JSON.parse(body.to_s)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    # What a UI says when the Bridge answers a route with 404: the worker runs
+    # code from before the route. Restarting it picks up the installed chi.
+    # @param cant [String] what the old worker can't do, e.g. "run commands"
+    def self.stale_worker_message(session_id, cant:)
+      "this session's worker runs an older chi and can't #{cant}; " \
+        "restart it: chi sessions stop #{session_id} && chi --resume #{session_id} (its turns still work)"
+    end
+
+    # Port of the live Bridge advertised in +session_dir+'s sidecar, or nil.
+    # A sidecar whose port refuses a quick connect is stale (its worker died)
+    # and is removed.
+    # @param session_dir [String]
+    # @return [Integer, nil]
+    def self.sidecar_port(session_dir, host: HOST)
+      sidecar = File.join(session_dir, SIDECAR_FILE)
+      return nil unless File.file?(sidecar)
+
+      data = JSON.parse(File.read(sidecar))
+      port = data["port"]
+      port = port.is_a?(Integer) ? port : port.to_i
+      return nil unless port.to_i > 0
+
+      # Validate liveness: stale sidecar after worker death causes ECONNREFUSED
+      # which surfaces as WEBrick ERROR. Probe quickly and clean up if dead.
+      begin
+        Socket.tcp(host, port, connect_timeout: PROBE_TIMEOUT).close
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT, SocketError, IOError, StandardError
+        begin
+          File.unlink(sidecar)
+        rescue StandardError
+          nil
+        end
+        return nil
+      end
+      port
+    rescue StandardError
+      nil
+    end
+
+    # @return [BridgeClient, nil] a client for the live Bridge in +session_dir+
+    def self.discover(session_id, session_dir:, host: HOST)
+      port = sidecar_port(session_dir, host: host)
+      port && new(session_id: session_id, port: port, host: host)
+    end
+
+    # How often a wait for a new worker's Bridge looks: a missing sidecar is
+    # one stat, and a 0.1 s step cost a create up to 0.1 s (the web's
+    # create landed on 0.53/0.63/0.73 s).
+    SPAWN_POLL_INTERVAL = 0.02
+
+    # Wait for a freshly spawned worker to publish its Bridge.
+    # @param timeout [Float] seconds
+    # @return [BridgeClient, nil] nil when no live sidecar appeared in time
+    def self.wait_for(session_id, session_dir:, timeout:, host: HOST)
+      port = poll(timeout, interval: SPAWN_POLL_INTERVAL) { sidecar_port(session_dir, host: host) }
+      port && new(session_id: session_id, port: port, host: host)
+    end
+
+    # Call the block every +interval+ seconds until it returns a truthy value
+    # or +timeout+ seconds have passed (it is always called at least once).
+    # @return [Object, nil] the block's first truthy value
+    def self.poll(timeout, interval: 0.1)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout.to_f
+      loop do
+        value = yield
+        return value if value
+        return nil if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+        sleep(interval)
+      end
+    end
+
+    attr_reader :session_id, :port, :host
+
+    # @param read_timeout [Numeric] see READ_TIMEOUT
+    def initialize(session_id:, port:, host: HOST, read_timeout: READ_TIMEOUT)
+      @session_id = session_id
+      @port = port
+      @host = host
+      @read_timeout = read_timeout
+    end
+
+    # 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).
+    # @return [Response]
+    def answer(id:, selected:, freeform: nil)
+      post("answer", { id: id, selected: selected, freeform: freeform, deadline: deadline }, read_body: true)
+    end
+
+    # POST /session/:id/question/dismiss: leave the question unanswered.
+    # 200 = dismissed, 409 = no longer pending (answered, cancelled, or
+    # another question), 404 = a worker older than the route, 408 = too late.
+    # @return [Response]
+    def dismiss_question(id:)
+      post("question/dismiss", { id: id, deadline: deadline }, read_body: true)
+    end
+
+    # POST /session/:id/turn. 202 = queued (body carries the enqueued_id the
+    # Bridge also announced in :turn_enqueued), 408 deadline_passed = the
+    # Bridge read it too late and dropped it (see DEADLINE_SHARE).
+    # @param client_id [String, nil] identifies the sending UI in the events
+    # @return [Response]
+    # @param no_interrupt [Boolean] run the turn with the raised iteration limit
+    # @param images [Array<Hash>] refs ({file:, name:}) to images already in
+    #   the session's images/ (409 images_unsupported from an older worker)
+    def post_turn(prompt:, client_id: nil, no_interrupt: false, images: nil)
+      body = { session_id: @session_id, prompt: prompt, client_id: client_id }
+      body[:no_interrupt] = true if no_interrupt
+      body[:images] = images if images && !images.empty?
+      body[:deadline] = deadline
+      post("turn", body, read_body: true)
+    end
+
+    # POST /session/:id/command: a session command (/model, /models,
+    # !rollback, !cmd, /continue) for the worker to run. 202 = queued (body
+    # carries the command_id its :command_ran will name), 400 = not a
+    # command, 404 = a worker older than the route, 408 = too late.
+    # @return [Response]
+    def post_command(line:, client_id: nil)
+      post("command", { line: line, client_id: client_id, deadline: deadline }, read_body: true)
+    end
+
+    # POST /session/:id/exit: ask the worker to exit now. 200 = it will
+    # (status "exiting"), 409 = something keeps it up (reason), 404 with
+    # error "not_found" = a worker older than the route.
+    # @param client_id [String] the asking UI, whose own streams don't hold
+    # @return [Response]
+    def request_exit(client_id:, delete: false)
+      body = { client_id: client_id }
+      body[:delete] = true if delete
+      post("exit", body, read_body: true)
+    end
+
+    # POST /session/:id/recap: the saved recap, and a new one asked for.
+    # @return [Response] 200 {enabled, saved, request, min_user_turns}
+    def request_recap
+      post("recap", {}, read_body: true)
+    end
+
+    # POST /session/:id/cancel. 202 = requested, 409 = no active turn.
+    # @return [Response] (status only)
+    def cancel(reason:)
+      post("cancel", { reason: reason }, read_body: false)
+    end
+
+    # GET /session/:id/<path> as JSON.
+    # @return [Hash, nil] the parsed body, or nil unless the Bridge answered 200
+    def get_json(path)
+      sock = TCPSocket.new(@host, @port)
+      sock.write("GET /session/#{@session_id}/#{path} HTTP/1.1\r\nHost: #{@host}:#{@port}\r\nConnection: close\r\n\r\n")
+      response = read_reply(sock, path)
+      sock.close rescue nil
+      return nil unless response
+
+      status_line = response.lines.first.to_s
+      return nil unless status_line.include?("200")
+
+      body = response.split("\r\n\r\n", 2)[1] || ""
+      JSON.parse(body)
+    rescue StandardError
+      nil
+    end
+
+    # Monotonic SSE cursor of the live Engine, from GET /session/:id/state.
+    # @return [Integer, nil]
+    def event_seq
+      state = get_json("state")
+      seq = state && state.dig("session_state_snapshot", "event_seq")
+      seq.nil? ? nil : seq.to_i
+    rescue StandardError
+      nil
+    end
+
+    # GET /session/:id/stream: yield the raw SSE body bytes as they arrive
+    # until the Bridge closes the stream.
+    # @param query [String] "" or "?from_seq=N"
+    # @param last_event_id [String, nil] reconnect cursor; the Bridge prefers it
+    #   over ?from_seq
+    # @param running [#call, nil] asked before every read, and every
+    #   STREAM_POLL seconds of silence: the stream ends once it returns
+    #   false. A quiet stream is never cut otherwise.
+    def stream(query: "", last_event_id: nil, running: nil)
+      sock = nil
+      # Absorb the probe→connect race around a resumed worker's bridge:
+      # the sidecar probe can succeed a moment before the worker dies (or
+      # the bridge socket briefly refuses). A few quick bounded retries
+      # avoid the silent empty-200 that EventSource would otherwise keep
+      # re-opening.
+      STREAM_CONNECT_ATTEMPTS.times do |attempt|
+        sock, = connect_stream(query: query, last_event_id: last_event_id)
+        break if sock
+
+        sleep(0.15 * (attempt + 1))
+      end
+      return unless sock
+
+      begin
+        loop do
+          if running
+            break unless running.call
+            next unless sock.wait_readable(STREAM_POLL)
+          end
+          chunk = sock.readpartial(4096)
+          yield chunk
+        rescue EOFError, IOError, Errno::ECONNRESET, Errno::ECONNREFUSED
+          break
+        end
+      ensure
+        sock&.close rescue nil
+      end
+    end
+
+    # Follow the session's events on a reader thread (see EventStream).
+    # @param snapshot [Boolean] join with a snapshot frame
+    # @param client_id [String, nil] names the stream (see EventStream)
+    # @yieldparam event [Hash] string-keyed event
+    # @return [EventStream] started
+    def follow(snapshot: true, client_id: nil, reconnect_delays: EventStream::DEFAULT_RECONNECT_DELAYS, &on_event)
+      EventStream.new(self, snapshot: snapshot, client_id: client_id, reconnect_delays: reconnect_delays,
+                            &on_event).start
+    end
+
+    # Open GET /session/:id/stream and read past the response headers.
+    # @param timeout [Float, nil] give up when the headers don't start in time
+    # @return [Array(TCPSocket, Integer), nil] the socket positioned at the
+    #   body and the HTTP status, or nil when the Bridge can't be reached
+    def connect_stream(query: "", last_event_id: nil, timeout: nil)
+      sock = TCPSocket.new(@host, @port)
+      lei = last_event_id.to_s.strip
+      last_event_line = lei.empty? ? "" : "Last-Event-ID: #{lei}\r\n"
+      sock.write("GET /session/#{@session_id}/stream#{query} HTTP/1.1\r\nHost: #{@host}:#{@port}\r\nAccept: text/event-stream\r\n#{last_event_line}Connection: keep-alive\r\n\r\n")
+      raise Errno::ETIMEDOUT if timeout && !sock.wait_readable(timeout)
+
+      status = sock.gets.to_s[/\AHTTP\/1\.[01] (\d{3})/, 1].to_i
+      while (line = sock.gets)
+        break if line.strip.empty?
+      end
+      [sock, status]
+    rescue SystemCallError, SocketError, IOError
+      sock&.close rescue nil
+      nil
+    end
+
+    private
+
+    # When this client stops waiting for a reply, as epoch seconds (see
+    # DEADLINE_SHARE). Wall clock: the worker runs on this machine and reads
+    # the same one.
+    def deadline = (Time.now.to_f + (@read_timeout * DEADLINE_SHARE)).round(3)
+
+    def post(path, payload, read_body:)
+      sock = TCPSocket.new(@host, @port)
+      json_body = JSON.generate(payload)
+      sock.write("POST /session/#{@session_id}/#{path} HTTP/1.1\r\nHost: #{@host}:#{@port}\r\nContent-Type: application/json\r\nContent-Length: #{json_body.bytesize}\r\nConnection: close\r\n\r\n#{json_body}")
+      reply = read_reply(sock, path, whole: read_body)
+      body = read_body ? reply.split("\r\n\r\n", 2)[1] : nil
+      Response.new(status: reply[/\AHTTP\/1\.[01] (\d{3})/, 1].to_i, body: body)
+    ensure
+      sock&.close rescue nil
+    end
+
+    # The reply up to the Bridge's close (or its first line only), within
+    # @read_timeout in all.
+    # @raise [Errno::ETIMEDOUT]
+    def read_reply(sock, path, whole: true)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @read_timeout
+      reply = +""
+      loop do
+        break if !whole && reply.include?("\n")
+
+        left = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        unless left.positive? && sock.wait_readable(left)
+          raise Errno::ETIMEDOUT, "bridge #{path}: no reply within #{@read_timeout}s"
+        end
+
+        reply << sock.readpartial(16_384)
+      rescue EOFError
+        break
+      end
+      reply.force_encoding(Encoding::UTF_8)
+    end
+  end
+end

data/lib/samagotchi/bundle_needs.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Samagotchi
+  autoload :MutedMemories, File.expand_path("muted_memories", __dir__)
+  autoload :Log, File.expand_path("log", __dir__)
+  module MemoryBundle
+    autoload :Provenance, File.expand_path("memory_bundle/provenance", __dir__)
+    autoload :Manifest, File.expand_path("memory_bundle/manifest", __dir__)
+  end
+
+  # The outside commands a bundle declares in its manifest's `needs:`
+  # (docs/memory.md). Advisory only: a PATH lookup in Ruby, no subprocess,
+  # nothing installed. Install/upgrade warn, `chi bundle status` lists, and
+  # the prompt's index marks a bundle memory whose need is missing.
+  module BundleNeeds
+    # Whether some PATH folder holds an executable file (not a directory)
+    # named +command+. An empty or missing PATH finds nothing.
+    def self.found?(command, path: ENV["PATH"])
+      return false if path.nil? || path.empty?
+
+      path.split(File::PATH_SEPARATOR).any? do |dir|
+        next false if dir.empty?
+
+        file = File.join(dir, command.to_s)
+        File.file?(file) && File.executable?(file)
+      end
+    end
+
+    # The needs (hashes with :command) whose command isn't found.
+    def self.missing(needs, path: ENV["PATH"])
+      Array(needs).reject { |need| found?(need[:command], path: path) }
+    end
+
+    # "[needs gh, jq: not found on PATH]", or nil when nothing is missing.
+    # No em dash: IndexUpdater.extract_description splits on " — ".
+    def self.marker(missing)
+      commands = Array(missing).map { |need| need[:command] }
+      return nil if commands.empty?
+
+      "[needs #{commands.join(", ")}: not found on PATH]"
+    end
+
+    # The prompt's index text for +scope+ with a marker on each line naming
+    # a memory of an installed bundle (of that scope) whose needs aren't all
+    # on +path+. Every other byte stays; with nothing missing the text comes
+    # back as is. Never raises: on any error the text comes back unchanged.
+    def self.annotate_index(text, scope, path: ENV["PATH"], bundles_dir: nil)
+      return text if text.nil? || text.empty?
+
+      markers = entry_markers(scope, path: path, bundles_dir: bundles_dir || MemoryBundle::Provenance.bundles_dir)
+      return text if markers.empty?
+
+      text.each_line.map do |line|
+        marker = markers[MutedMemories.index_line_name(line)]
+        next line unless marker
+
+        body = line.chomp
+        "#{body} #{marker}#{line[body.length..]}"
+      end.join
+    rescue StandardError => e
+      Log.debug(:memory, "bundle_needs_failed", error: e.class.name, msg: e.message.to_s[0, 200])
+      text
+    end
+
+    # entry name → marker, for the installed bundles of +scope+ with a
+    # missing need. A manifest.json or needs: that doesn't parse is skipped.
+    def self.entry_markers(scope, path:, bundles_dir:)
+      return {} unless Dir.exist?(bundles_dir)
+
+      Dir[File.join(bundles_dir, "*", "manifest.json")].sort.each_with_object({}) do |mjson, acc|
+        data = begin
+          JSON.parse(File.read(mjson), symbolize_names: true)
+        rescue JSON::ParserError, SystemCallError
+          next
+        end
+        next unless data.is_a?(Hash) && data[:scope].to_s == scope.to_s
+        next unless data[:needs].is_a?(Array) && !data[:needs].empty?
+
+        needs = begin
+          MemoryBundle::Manifest.parse_needs(data[:needs])
+        rescue MemoryBundle::Manifest::ValidationError
+          next
+        end
+        marker = marker(missing(needs, path: path))
+        next unless marker
+
+        (data[:files].is_a?(Hash) ? data[:files].keys : []).each do |key|
+          name = MutedMemories.normalize(key)
+          acc[name] ||= marker if name
+        end
+      end
+    end
+    private_class_method :entry_markers
+  end
+end

data/lib/samagotchi/bundles/btw/manifest.yml

@@ -0,0 +1,10 @@
+---
+name: btw
+version: 0.1.1
+scope: system
+description: "/btw <question>: a side answer about the conversation, as a card in every UI, even mid-turn; Keep as session forks it into a child session"
+trust_level: reviewed
+plugin:
+  file: plugin.rb
+  sha256: sha256:d12a970e7e5ada617fc7d55ee1de80b576835092d268af620f3f7241188e3297
+requires_chi: ">= 0.1.30"