solid_loop 0.0.4 → 0.0.5

data/lib/solid_loop/configuration.rb

@@ -58,6 +58,38 @@ module SolidLoop
     # `LeaseRenewer#register`). Mirrors `SolidLoop::Base#max_duration`'s default (2h).
     attr_reader :default_max_duration
 
+    # How many times to RE-send an LLM request that failed transiently, on top of
+    # the first attempt. 0 disables retrying. Transient 429/5xx are routine for
+    # hosted providers — a shared-model 429 that carried `Retry-After: 30` used to
+    # fail the whole loop instantly, discarding the provider's own instruction.
+    attr_reader :llm_retries
+
+    # Backoff base (seconds). Delay for attempt N is `base * 2**(N-1)`, capped at
+    # `llm_retry_max_delay`, and OVERRIDDEN by the provider's `Retry-After` when
+    # it sends one (still capped) — the provider knows better than the curve.
+    attr_reader :llm_retry_base_delay
+
+    # Ceiling (seconds) on any single backoff wait, `Retry-After` included. A
+    # provider asking for a 30-minute wait must not park a worker for 30 minutes.
+    attr_reader :llm_retry_max_delay
+
+    # HTTP statuses treated as transient. 408/429 and the 5xx family; deliberately
+    # NOT 400/401/403/404/422 — those are deterministic and retrying only burns
+    # quota. Note 409 is included for providers that use it for "model loading".
+    attr_reader :llm_retry_statuses
+
+    # How long to keep `solid_loop_events` (wire logs) and the inbound MCP
+    # sessions issued by Mcp::Server. `nil` (the default) means keep forever —
+    # unbounded growth is the status quo, and silently deleting a host's audit
+    # trail on upgrade would be the wrong default. An ActiveSupport::Duration or
+    # a number of seconds. Swept by SolidLoop::Janitor via SolidLoop.prune!.
+    attr_reader :event_retention
+    attr_reader :mcp_inbound_session_retention
+
+    # Rows deleted per statement during a retention sweep. Keeps each lock short
+    # on tables that are being written to concurrently.
+    attr_reader :janitor_batch_size
+
     def initialize
       @lease_margin          = 60
       @queued_reap_threshold = 300
@@ -68,6 +100,56 @@ module SolidLoop
       # `max_duration` rather than never.
       @lease_leak_grace      = 300
       @default_max_duration  = 2.hours.to_i
+      @llm_retries           = 2
+      @llm_retry_base_delay  = 1.0
+      @llm_retry_max_delay   = 60.0
+      @llm_retry_statuses    = [ 408, 409, 429, 500, 502, 503, 504 ].freeze
+      @event_retention               = nil
+      @mcp_inbound_session_retention = nil
+      @janitor_batch_size            = 1_000
+    end
+
+    def event_retention=(duration)
+      @event_retention = normalize_retention(duration, "event_retention")
+    end
+
+    def mcp_inbound_session_retention=(duration)
+      @mcp_inbound_session_retention = normalize_retention(duration, "mcp_inbound_session_retention")
+    end
+
+    def janitor_batch_size=(count)
+      count = Integer(count)
+      raise ArgumentError, "janitor_batch_size must be > 0" unless count.positive?
+
+      @janitor_batch_size = count
+    end
+
+    def llm_retries=(count)
+      count = Integer(count)
+      raise ArgumentError, "llm_retries must be >= 0" if count.negative?
+
+      @llm_retries = count
+    end
+
+    def llm_retry_base_delay=(seconds)
+      seconds = Float(seconds)
+      raise ArgumentError, "llm_retry_base_delay must be > 0" unless seconds.positive?
+
+      @llm_retry_base_delay = seconds
+    end
+
+    def llm_retry_max_delay=(seconds)
+      seconds = Float(seconds)
+      raise ArgumentError, "llm_retry_max_delay must be > 0" unless seconds.positive?
+
+      @llm_retry_max_delay = seconds
+    end
+
+    def llm_retry_statuses=(statuses)
+      statuses = Array(statuses).map { |s| Integer(s) }
+      raise ArgumentError, "llm_retry_statuses must not be empty" if statuses.empty?
+
+      @llm_retry_statuses = statuses.freeze
     end
 
     def lease_margin=(seconds)
@@ -152,6 +234,17 @@ module SolidLoop
 
     private
 
+    # nil (keep forever) or a positive Duration. A zero/negative window would
+    # delete every row on the next sweep, which is never what an operator means.
+    def normalize_retention(duration, name)
+      return nil if duration.nil?
+
+      seconds = duration.respond_to?(:to_i) ? duration.to_i : Integer(duration)
+      raise ArgumentError, "#{name} must be > 0 (use nil to keep forever)" unless seconds.positive?
+
+      duration
+    end
+
     # The slowest resolved HTTP MCP client timeout across the agent's `mcps`, or
     # nil if the agent exposes none / cannot be inspected. Matches the resolution
     # in Mcp::ClientFactory#transport_for (`mcp_config[:timeout] || 60` for a url:

data/lib/solid_loop/engine.rb

@@ -7,6 +7,14 @@ module SolidLoop
   class Engine < ::Rails::Engine
     isolate_namespace SolidLoop
 
+    # Runs before the host's own `to_prepare` blocks (engine callbacks are
+    # registered first), so a host that customizes the stack in `to_prepare`
+    # re-applies its changes onto a freshly rebuilt stack rather than onto a
+    # stale one — and never accumulates duplicates across reloads.
+    config.to_prepare do
+      SolidLoop.reset_middlewares!
+    end
+
     initializer "solid_loop.mime_types" do
       Mime::Type.register "text/vnd.turbo-stream.html", :turbo_stream unless Mime[:turbo_stream]
     end

data/lib/solid_loop/janitor.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  # Age-based retention for the two tables that grow without bound: wire-log
+  # Events (one per LLM turn, per tool call and per inbound MCP request) and the
+  # McpInboundSessions issued to external clients.
+  #
+  # Nothing here is on by default — an operator opts in per table, because "how
+  # long must the audit trail survive" is a business answer, not a gem's:
+  #
+  #   SolidLoop.configure do |c|
+  #     c.event_retention                = 90.days
+  #     c.mcp_inbound_session_retention  = 30.days
+  #   end
+  #
+  # Deletes in batches (`janitor_batch_size`) so a sweep never takes one long
+  # lock on a hot, append-only table. Idempotent and safe to run concurrently:
+  # two janitors racing on the same batch both issue `delete_all` and the loser
+  # simply deletes zero rows.
+  #
+  # Rows are removed with `delete_all` — no callbacks, no instantiation. That is
+  # deliberate for volume, and the only ActiveRecord callback in play would be
+  # `McpInboundSession`'s `dependent: :destroy`, which this replaces explicitly
+  # by deleting a doomed session's events first (see `prune_inbound_sessions!`).
+  #
+  # NOTE: the first sweep after enabling retention on an existing install may
+  # have years of backlog to clear and can run long. Either let the recurring
+  # job chip away at it, or do the initial bulk delete out of band.
+  class Janitor
+    Result = Struct.new(:events_deleted, :inbound_sessions_deleted, keyword_init: true) do
+      def total = events_deleted + inbound_sessions_deleted
+    end
+
+    def initialize(now: Time.current)
+      @now    = now
+      @config = SolidLoop.config
+    end
+
+    def call
+      result = Result.new(
+        events_deleted:           prune_events!,
+        inbound_sessions_deleted: prune_inbound_sessions!
+      )
+      SolidLoop.last_pruned_at = @now
+      log(result)
+      result
+    end
+
+    private
+
+    def prune_events!
+      retention = @config.event_retention
+      return 0 unless retention
+
+      delete_in_batches(SolidLoop::Event.where(created_at: ...(@now - retention)))
+    end
+
+    # Sessions are pruned by CREATION age, not by `last_used_at` or
+    # `terminated_at`: a client that never terminates and never returns would
+    # otherwise pin its row forever, which is precisely the leak being closed.
+    #
+    # A session's events are deleted first. They may still exist even after
+    # `prune_events!` — the two retentions are independent, and a shorter session
+    # retention would otherwise strand events pointing at a deleted session.
+    def prune_inbound_sessions!
+      retention = @config.mcp_inbound_session_retention
+      return 0 unless retention
+
+      scope   = SolidLoop::McpInboundSession.where(created_at: ...(@now - retention))
+      deleted = 0
+
+      loop do
+        ids = scope.limit(batch_size).pluck(:id)
+        break if ids.empty?
+
+        SolidLoop::Event
+          .where(eventable_type: "SolidLoop::McpInboundSession", eventable_id: ids)
+          .delete_all
+        deleted += SolidLoop::McpInboundSession.where(id: ids).delete_all
+      end
+
+      deleted
+    end
+
+    def delete_in_batches(scope)
+      deleted = 0
+      loop do
+        ids = scope.limit(batch_size).pluck(:id)
+        break if ids.empty?
+
+        deleted += scope.model.where(id: ids).delete_all
+      end
+      deleted
+    end
+
+    def batch_size
+      @config.janitor_batch_size
+    end
+
+    def log(result)
+      return unless defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+      return if result.total.zero?
+
+      Rails.logger.info(
+        "SolidLoop::Janitor pruned #{result.events_deleted} event(s) and " \
+        "#{result.inbound_sessions_deleted} inbound session(s)"
+      )
+    end
+  end
+end

data/lib/solid_loop/mcp/toolset.rb

@@ -121,6 +121,28 @@ module SolidLoop
           name.to_s.demodulize.underscore
         end
 
+        # The version reported in `initialize` -> serverInfo.version. Defaults to
+        # the GEM's version, which is almost never what a host means: semantically
+        # this is the version of YOUR MCP server, and leaking the transport's
+        # version tells clients nothing while exposing an internal detail.
+        #
+        #   class SearchTools < SolidLoop::Mcp::Toolset
+        #     server_name    "search"
+        #     server_version "1.0.0"
+        #   end
+        def server_version(value = nil)
+          @server_version = value.to_s if value
+
+          klass = self
+          while klass.respond_to?(:own_tools)
+            explicit = klass.instance_variable_get(:@server_version)
+            return explicit if explicit
+            klass = klass.superclass
+          end
+
+          SolidLoop::VERSION
+        end
+
         def tool(tool_name, description:, input_schema:, &block)
           raise ArgumentError, "tool '#{tool_name}' requires a block" unless block
 
@@ -178,6 +200,10 @@ module SolidLoop
         body =
           case request["method"]
           when "initialize"   then handle_initialize(request, context) { |sid| session_id = sid }
+          # Base-protocol liveness check: either party may send it at any time and
+          # the responder MUST reply promptly with an empty result. Answering
+          # "method not found" makes well-behaved clients treat the server as dead.
+          when "ping"         then success_envelope(request, {})
           when "tools/list"   then success_envelope(request, "tools" => tool_specs)
           when "tools/call"   then handle_tools_call(request, context)
           when "prompts/list" then success_envelope(request, "prompts" => prompt_specs)
@@ -201,6 +227,93 @@ module SolidLoop
         nil
       end
 
+      # --- Dynamic catalogs -----------------------------------------------------
+      #
+      # The `tool` / `prompt` DSL registers at class-load time, which is wrong for
+      # a host whose catalog lives in the database and changes without a deploy.
+      # These four instance methods are the seam: they default to the static DSL,
+      # and overriding them serves the catalog from anywhere. They are consulted
+      # on EVERY request (list, get, call) and by `capabilities`, so a prompt row
+      # added a second ago is advertised on the next `prompts/list`.
+      #
+      # Build entries with the same Structs the DSL uses:
+      #
+      #   def available_prompts
+      #     SavedPrompt.active.each_with_object({}) do |row, acc|
+      #       acc[row.name] = PromptDefinition.new(
+      #         name: row.name, description: row.description, arguments: row.arguments,
+      #         handler: ->(args, _ctx) { format(row.body, args) }
+      #       )
+      #     end
+      #   end
+      #
+      # Must be TOTAL: `capabilities` calls `available_prompts` during
+      # `initialize`, so a raising override fails the handshake, not one request.
+      # Keys are String names; return {} for "none".
+      def available_tools
+        self.class.tools
+      end
+
+      def find_tool(name)
+        available_tools[name.to_s]
+      end
+
+      def available_prompts
+        self.class.prompts
+      end
+
+      def find_prompt(name)
+        available_prompts[name.to_s]
+      end
+
+      # --- Public extension contract -------------------------------------------
+      #
+      # `deliver` is the documented override point ("the toolset IS the
+      # transport"), so the envelope builders an override needs to answer a
+      # request are PUBLIC API and covered by the gem's compatibility promise.
+      # They were private, which forced every override to reach through `send` or
+      # to depend on private methods that a patch release could rename.
+      #
+      #   def deliver(payload, session_id: nil, context: nil)
+      #     request = json_boundary(payload)
+      #     return super unless request["method"] == "resources/list"
+      #
+      #     Result.new(body: success_envelope(request, "resources" => []),
+      #                session_id: session_id, raw_request: payload,
+      #                raw_response: nil, status: 200)
+      #   end
+
+      def success_envelope(request, result)
+        { "jsonrpc" => "2.0", "id" => request["id"], "result" => result }
+      end
+
+      def error_envelope(request, code, message)
+        { "jsonrpc" => "2.0", "id" => request["id"], "error" => { "code" => code, "message" => message } }
+      end
+
+      # Round-trips through JSON so symbol keys, Time, BigDecimal and friends
+      # arrive at the client exactly as a remote transport would deliver them —
+      # in-process and HTTP behavior cannot drift.
+      def json_boundary(value)
+        JSON.parse(JSON.generate(value))
+      end
+
+      # Wraps a handler's return value in MCP result shape: a Hash becomes both
+      # `structuredContent` and its serialized text twin, anything else becomes a
+      # single text block.
+      def tool_result(value)
+        case value
+        when Hash
+          structured = json_boundary(value)
+          {
+            "content"           => [ { "type" => "text", "text" => JSON.generate(structured) } ],
+            "structuredContent" => structured
+          }
+        else
+          { "content" => [ { "type" => "text", "text" => value.to_s } ] }
+        end
+      end
+
       private
 
       def handle_initialize(request, context)
@@ -209,19 +322,19 @@ module SolidLoop
         success_envelope(request,
           "protocolVersion" => "2024-11-05",
           "capabilities"    => capabilities,
-          "serverInfo"      => { "name" => self.class.server_name, "version" => SolidLoop::VERSION })
+          "serverInfo"      => { "name" => self.class.server_name, "version" => self.class.server_version })
       end
 
       # prompts is advertised only when prompts are actually declared.
       def capabilities
         caps = { "tools" => {} }
-        caps["prompts"] = {} if self.class.prompts.any?
+        caps["prompts"] = {} if available_prompts.any?
         caps
       end
 
       def handle_tools_call(request, context)
         params     = request["params"] || {}
-        definition = self.class.tools[params["name"].to_s]
+        definition = find_tool(params["name"])
         return error_envelope(request, -32602, "Unknown tool: #{params['name']}") unless definition
 
         arguments = params["arguments"] || {}
@@ -268,7 +381,7 @@ module SolidLoop
       # exceptions become a -32603 protocol error instead of propagating.
       def handle_prompts_get(request, context)
         params     = request["params"] || {}
-        definition = self.class.prompts[params["name"].to_s]
+        definition = find_prompt(params["name"])
         return error_envelope(request, -32602, "Unknown prompt: #{params['name']}") unless definition
 
         arguments = params["arguments"] || {}
@@ -301,7 +414,7 @@ module SolidLoop
       end
 
       def prompt_specs
-        self.class.prompts.values.map do |p|
+        available_prompts.values.map do |p|
           spec = { "name" => p.name, "description" => p.description }
           spec["arguments"] = json_boundary(p.arguments) if p.arguments.any?
           spec
@@ -309,7 +422,7 @@ module SolidLoop
       end
 
       def tool_specs
-        self.class.tools.values.map do |t|
+        available_tools.values.map do |t|
           {
             "name"        => t.name,
             "description" => t.description,
@@ -317,31 +430,6 @@ module SolidLoop
           }
         end
       end
-
-      def tool_result(value)
-        case value
-        when Hash
-          structured = json_boundary(value)
-          {
-            "content"           => [ { "type" => "text", "text" => JSON.generate(structured) } ],
-            "structuredContent" => structured
-          }
-        else
-          { "content" => [ { "type" => "text", "text" => value.to_s } ] }
-        end
-      end
-
-      def success_envelope(request, result)
-        { "jsonrpc" => "2.0", "id" => request["id"], "result" => result }
-      end
-
-      def error_envelope(request, code, message)
-        { "jsonrpc" => "2.0", "id" => request["id"], "error" => { "code" => code, "message" => message } }
-      end
-
-      def json_boundary(value)
-        JSON.parse(JSON.generate(value))
-      end
     end
   end
 end

data/lib/solid_loop/pipeline/builder.rb

@@ -1,6 +1,24 @@
 module SolidLoop
   class Pipeline
     class Builder
+      # Raised when a positional operation names a middleware the stack does not
+      # contain. Placement is the whole point of these methods, so guessing a
+      # position is worse than failing: a middleware that lands before
+      # AgentInitialization sees an unpopulated context, and one that lands after
+      # the terminal link may never run at all. Both fail far from the typo that
+      # caused them.
+      class UnknownMiddleware < ArgumentError
+        def initialize(target, middlewares)
+          known = middlewares.map { |m| m.respond_to?(:name) ? m.name : m.inspect }
+          super(<<~MSG.strip)
+            #{target.inspect} is not in this middleware stack, so there is no position to insert at.
+            Known middlewares, in order: #{known.join(', ')}
+            If the target looks like it IS there, the stack may be holding class objects
+            from an earlier code load — compare by `.equal?`, not by name.
+          MSG
+        end
+      end
+
       attr_reader :middlewares
 
       def initialize(middlewares = [])
@@ -12,27 +30,30 @@ module SolidLoop
       end
 
       def insert_before(target, middleware)
-        index = @middlewares.index(target) || 0
-        @middlewares.insert(index, middleware)
+        @middlewares.insert(index_of!(target), middleware)
       end
 
       def insert_after(target, middleware)
-        index = @middlewares.index(target) || @middlewares.size - 1
-        @middlewares.insert(index + 1, middleware)
+        @middlewares.insert(index_of!(target) + 1, middleware)
       end
 
       def replace(target, middleware)
-        index = @middlewares.index(target)
-        if index
-          @middlewares[index] = middleware
-        else
-          @middlewares << middleware
-        end
+        @middlewares[index_of!(target)] = middleware
       end
 
+      # Lenient on purpose, unlike the positional methods above: "this middleware
+      # should not run" is unambiguous whether or not it is currently present, so
+      # a repeated or defensive delete is a legitimate no-op rather than a
+      # mistake. Returns the removed middleware, or nil.
       def delete(target)
         @middlewares.delete(target)
       end
+
+      private
+
+      def index_of!(target)
+        @middlewares.index(target) or raise UnknownMiddleware.new(target, @middlewares)
+      end
     end
   end
 end

data/lib/solid_loop/redaction.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidLoop
+  # One redaction rule set for everything that persists provider wire detail —
+  # wire logs, event payloads AND the error text written onto a loop/message.
+  #
+  # It lives here rather than inside EventLogging because the two write paths
+  # diverged: EventLogging redacted, while ErrorHandling wrote `e.message`
+  # verbatim into `loop.error_message`. That is safe for header-auth dialects
+  # (open_ai, anthropic) but NOT for Gemini, which carries the API key in the
+  # URL query (`?key=…`) — and a Faraday error message embeds the URL, so the
+  # key reached `error_message` and from there the admin UI and any host API
+  # that surfaces it.
+  module Redaction
+    module_function
+
+    # Header-form credentials (`Authorization: Bearer …`) and key-bearing query
+    # parameters (`?key=…`, `&api_key=…`). Returns a String; nil in => "" out,
+    # so callers must guard if they need to preserve nil.
+    def redact_credentials(value)
+      value.to_s
+        .gsub(/(Authorization|x-api-key|api-key):[^\r\n]*/i, "\\1: [REDACTED]")
+        .gsub(/([?&](?:key|api_key|api-key)=)[^&\s]*/i, "\\1[REDACTED]")
+    end
+  end
+end

data/lib/solid_loop/version.rb

@@ -1,3 +1,3 @@
 module SolidLoop
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/solid_loop.rb

@@ -2,9 +2,11 @@ require "solid_loop/version"
 require "solid_loop/engine"
 require "solid_loop/mcp_client"
 require "solid_loop/configuration"
+require "solid_loop/redaction"
 require "solid_loop/lease_renewer"
 require "solid_loop/lease_heartbeat"
 require "solid_loop/reaper"
+require "solid_loop/janitor"
 
 module SolidLoop
   class CancellationError < StandardError; end
@@ -24,6 +26,11 @@ module SolidLoop
   # transaction, so raising here rolls back the enclosing state change instead
   # of committing it with no successor job to carry the loop forward.
   class EnqueueError < StandardError; end
+  # Raised by `Base#resume!` when the loop is held by an admin freeze. A TYPED
+  # error (not a bare StandardError with a magic string) so a host can tell an
+  # expected user-facing case — "unfreeze it first", a 422 — apart from a real
+  # fault, without matching on message text that the gem is free to reword.
+  class FrozenLoopError < StandardError; end
 
   class << self
     # Enqueue a successor job, raising unless ActiveJob confirms it was actually
@@ -46,6 +53,18 @@ module SolidLoop
     # polymorphic subject (which the engine can't route to on its own). A
     # callable taking the loop and returning a URL string, or a Hash
     # { url:, label: }. Left nil by default — the admin degrades to plain text.
+    #
+    # The callable is invoked plainly (`resolver.call(loop)`), NOT instance_exec'd
+    # in a view, so there is no `main_app` proxy in its binding — build paths with
+    # `Rails.application.routes.url_helpers`. Return nil for subjects it does not
+    # handle, and make it total: an exception here would take down the admin.
+    #
+    #   SolidLoop.subject_resolver = lambda do |loop|
+    #     next nil unless loop.subject_type == "Order"
+    #     order = loop.subject or next nil
+    #     { url: Rails.application.routes.url_helpers.order_path(order),
+    #       label: "Order ##{order.id}" }
+    #   end
     attr_accessor :subject_resolver
 
     # Durable-lease + reaper configuration (see docs/decisions/durable_attempt_lease.md).
@@ -61,6 +80,20 @@ module SolidLoop
       Reaper.new(now: now).call
     end
 
+    # Apply the configured retention windows, deleting aged-out wire-log Events
+    # and inbound MCP sessions. A no-op until a host sets `event_retention` /
+    # `mcp_inbound_session_retention`. Idempotent; safe to run concurrently.
+    # Returns the SolidLoop::Janitor::Result. Host installs the recurrence via
+    # SolidLoop::JanitorJob — the gem does NOT own a scheduler.
+    def prune!(now: Time.current)
+      Janitor.new(now: now).call
+    end
+
+    # Timestamp of the last completed `prune!` — the retention counterpart of
+    # `last_reaped_at`, for hosts alerting on "has the janitor run recently?".
+    # Process-local.
+    attr_accessor :last_pruned_at
+
     # Timestamp of the last successful `reap!` — a liveness health signal for
     # hosts to alert on ("has the reaper run recently?"). nil until the first
     # reap completes. Process-local (each worker tracks its own last run).
@@ -87,6 +120,20 @@ module SolidLoop
       ])
     end
 
+    # Drops the memoized middleware stacks so they are rebuilt from freshly
+    # loaded constants. The stacks are memoized on this module, which lives in
+    # `lib/` and is therefore NEVER reloaded, while the middleware classes live
+    # in the engine's `app/` and ARE reloaded in development. Without this reset
+    # the memo keeps class objects from an earlier load: `Array#index` compares
+    # by `==`, an old class object is not equal to its reloaded replacement, and
+    # every positional Builder call against a current constant fails to find its
+    # target. The Engine calls this on `to_prepare`, before host initializers
+    # re-apply their own customization.
+    def reset_middlewares!
+      @llm_middlewares = nil
+      @tool_middlewares = nil
+    end
+
     def configure
       yield self
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_loop
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Ruslan
@@ -86,7 +86,9 @@ files:
 - app/controllers/solid_loop/messages_controller.rb
 - app/controllers/solid_loop/tool_calls_controller.rb
 - app/helpers/solid_loop/application_helper.rb
+- app/helpers/solid_loop/metrics_helper.rb
 - app/jobs/solid_loop/application_job.rb
+- app/jobs/solid_loop/janitor_job.rb
 - app/jobs/solid_loop/llm_completion_job.rb
 - app/jobs/solid_loop/observe_broadcast_job.rb
 - app/jobs/solid_loop/reaper_job.rb
@@ -166,6 +168,7 @@ files:
 - db/migrate/20260715000300_solid_loop_add_tool_lease.rb
 - db/migrate/20260715000400_solid_loop_add_lease_running_check.rb
 - db/migrate/20260715000500_solid_loop_add_tool_lease_pair_check.rb
+- db/migrate/20260819000100_solid_loop_add_retention_indexes.rb
 - docs/contributing/coverage.md
 - docs/decisions/durable_attempt_lease.md
 - docs/decisions/mcp-only-tooling.md
@@ -176,9 +179,11 @@ files:
 - docs/guides/llm_middlewares.md
 - docs/guides/mcp_transports.md
 - docs/guides/tool_middlewares.md
+- docs/validation.md
 - lib/solid_loop.rb
 - lib/solid_loop/configuration.rb
 - lib/solid_loop/engine.rb
+- lib/solid_loop/janitor.rb
 - lib/solid_loop/lease_heartbeat.rb
 - lib/solid_loop/lease_renewer.rb
 - lib/solid_loop/llm_metrics.rb
@@ -198,8 +203,8 @@ files:
 - lib/solid_loop/pipeline/context.rb
 - lib/solid_loop/pipeline/tool_context.rb
 - lib/solid_loop/reaper.rb
+- lib/solid_loop/redaction.rb
 - lib/solid_loop/version.rb
-- lib/tasks/coverage.rake
 - lib/tasks/solid_loop_tasks.rake
 homepage: https://github.com/ruslan/solid_loop
 licenses: