lex-ollama 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28df561b00b58c7cb179b9904aed61a5aa7e278140306dadb3b4b2665eaab824
-  data.tar.gz: 446afaab9d80e6a4f62286a1f5ccc1c023bdbb178dba043cb96081412991b2d3
+  metadata.gz: 8657f3e11e11fcd2ee34e12317bf7698bcfea1e907006c76f9a07326996c7a69
+  data.tar.gz: d1c1bbb05dc6a3a0071b4474a45a074b0d4929cd4b48b7488b5aa10539a9a6ee
 SHA512:
-  metadata.gz: 2915cfe6e4e959e61ee5b8ce68e7da784b4c6001cfe0c3acdb0a4e0f804da79a1e46a17b7c5297b9dd4f26e58bbae504066f5874d8cd82d6ea223b3dfc561bbb
-  data.tar.gz: cb1337292d4bb7c94603612e03dbdbcbd9a41c2a94e56f4bbfad1132d403f6d14b0316091017745ee2d282ccc426bdcdb65b137f66f07f2a505d231792e424b0
+  metadata.gz: e2a8622a2914cdfbc04b365d1ca7a9e8d35b4daa656931fd23a6e010b25b5a8ed6699246bffdbe0bfe064757ad26cad8f3664fe8c1dd2d1c606220dc932af45f
+  data.tar.gz: ea975e9ac1c89621d41c274b6040bb92760672f9d4a2db223ea6c08371f7ed8e8a2dc810417b9b5b2beb9ce30fccb64544f24c11ae815422e5b99f5a43a48517

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.3.2] - 2026-04-08
+
+### Changed
+- `Transport::Exchanges::LlmRequest` now inherits `Legion::LLM::Fleet::Exchange` instead of declaring exchange properties independently — prevents silent divergence if the canonical exchange definition changes
+- `Transport::Queues::ModelRequest` switched from durable quorum queue to classic auto-delete with `x-max-priority: 10` — enables `basic.return` feedback when all workers disconnect; added `dlx_enabled: false` to prevent DLX provisioning on ephemeral queues
+- `Transport::Messages::LlmResponse` now inherits `Legion::LLM::Fleet::Response` instead of `Legion::Transport::Message` — gains wire protocol compliance (`type: 'llm.fleet.response'`, `message_context` propagation, default-exchange publishing, `resp_` prefixed message_id); overrides `app_id` to `'lex-ollama'`
+- `Runners::Fleet#handle_request` now accepts and propagates `message_context` verbatim from request to response; rejects `stream: true` requests with `unsupported_streaming` error; builds full wire protocol response envelope (routing, tokens, timestamps, audit, cost, stop)
+- `Runners::Fleet#publish_reply` switched from positional to keyword arguments; uses `fleet_correlation_id` instead of `correlation_id` to avoid collision with Legion task tracking
+- `Runners::Fleet#dispatch` now resolves Ollama host from `Legion::Settings` instead of using hardcoded default
+- `Actor::ModelWorker` now sets `prefetch(1)` for fair consumer dispatch; reads `consumer_priority` from `legion.ollama.fleet.consumer_priority` settings; passes `x-priority` in `subscribe_options`; injects `message_context: {}` default in `process_message`
+
+### Added
+- `Runners::Fleet#publish_error` — publishes `Legion::LLM::Fleet::Error` to caller's reply_to queue on validation failures (e.g., unsupported streaming)
+- `Runners::Fleet#build_response_body` — constructs wire protocol response body with routing, tokens, timestamps, audit, cost, and stop blocks
+
 ## [0.3.1] - 2026-04-08
 
 ### Added

data/CLAUDE.md

@@ -12,7 +12,7 @@ reporting, and **fleet queue subscription** for receiving routed LLM requests fr
 
 **GitHub**: https://github.com/LegionIO/lex-ollama
 **License**: MIT
-**Version**: 0.3.1
+**Version**: 0.3.2
 **Specs**: 82 examples (12 spec files) — fleet additions add ~35 more
 
 ---
@@ -38,11 +38,11 @@ Legion::Extensions::Ollama
 ├── Client             # Standalone client class (includes all runners, holds @config)
 ├── Transport/         # (loaded only when Legion::Extensions::Core is present)
 │   ├── Exchanges/
-│   │   └── LlmRequest   # topic exchange 'llm.request'
+│   │   └── LlmRequest   # references Legion::LLM::Fleet::Exchange ('llm.request')
 │   ├── Queues/
-│   │   └── ModelRequest # parametric queue — one per (type, model) pair
+│   │   └── ModelRequest # parametric queue — one per (type, model) pair, auto-delete
 │   └── Messages/
-│       └── LlmResponse  # reply message published back to reply_to
+│       └── LlmResponse  # Legion::LLM::Fleet::Response subclass, reply via default exchange
 └── Actor/
     └── ModelWorker    # subscription actor — one per registered model/type
 ```
@@ -80,9 +80,12 @@ llm.request.ollama.generate.llama3.2
 
 ### Queue Strategy
 
-Each model+type combination gets its own **durable quorum queue** with a routing key that matches
+Each model+type combination gets its own **auto-delete queue** with a routing key that matches
 its queue name exactly. Multiple nodes carrying the same model compete fairly (no SAC) — any
 subscriber can serve. The queue name is identical to the routing key for clarity in the management UI.
+RabbitMQ policies (applied externally via Terraform) set `max-length` and
+`overflow: reject-publish` on `llm.request.*` queues. Queue priority is enabled by declaring
+`x-max-priority: 10` on the queue itself (and may also be mirrored by policy for consistency).
 
 ### Configuration
 
@@ -106,20 +109,24 @@ The extension spawns one `Actor::ModelWorker` per subscription entry at boot.
 ### Data Flow
 
 ```
-Publisher (lex-llm-gateway / any fleet node)
+Publisher (legion-llm Fleet::Dispatcher / any fleet node)
   │  routing_key: "llm.request.ollama.embed.nomic-embed-text"
+  │  AMQP type: 'llm.fleet.request'
+  │  Body includes: message_context { conversation_id, message_id, parent_message_id, message_seq, request_id, exchange_id }
   ▼
 Exchange: llm.request  [topic, durable]
   │
-  └── Queue: llm.request.ollama.embed.nomic-embed-text  [quorum]
+  └── Queue: llm.request.ollama.embed.nomic-embed-text  [auto-delete]
             ▼
        Actor::ModelWorker (type=embed, model=nomic-embed-text)
             ▼
        Runners::Fleet#handle_request
+            │  copies message_context from request
             ▼
        Ollama::Client#embed(model: 'nomic-embed-text', ...)
             ▼
-       Transport::Messages::LlmResponse → reply_to queue (if present)
+       Fleet::Response (type: 'llm.fleet.response') → reply_to queue
+            Body includes: message_context (copied), response_message_id
 ```
 
 ### Standalone Mode (no Legion runtime)
@@ -152,6 +159,33 @@ The gem still works as a pure HTTP client library without AMQP, exactly as befor
 
 ---
 
+## Wire Protocol & Message Classes
+
+Fleet messages inherit from `Legion::LLM::Transport::Message` (defined in legion-llm), which
+extends `Legion::Transport::Message` with `message_context` propagation and LLM-specific headers.
+
+```
+Legion::Transport::Message                (platform base)
+  └── Legion::LLM::Transport::Message     (LLM base — message_context, llm_headers)
+       ├── Legion::LLM::Fleet::Request    (type: 'llm.fleet.request',  app_id: 'legion-llm')
+       ├── Legion::LLM::Fleet::Response   (type: 'llm.fleet.response', app_id: 'lex-ollama')
+       └── Legion::LLM::Fleet::Error      (type: 'llm.fleet.error',    app_id: 'lex-ollama')
+```
+
+Every fleet message carries `message_context` in the body for end-to-end tracing:
+```
+message_context:
+  conversation_id, message_id, parent_message_id, message_seq, request_id, exchange_id
+```
+
+A subset (`conversation_id`, `message_id`, `request_id`) is promoted to AMQP headers
+(`x-legion-llm-conversation-id`, etc.) for filtering without body parsing.
+
+See: `docs/plans/2026-04-08-fleet-wire-protocol.md` for full AMQP property mapping,
+platform-wide standard, and per-message-type specifications.
+
+---
+
 ## Dependencies
 
 | Gem | Purpose |
@@ -159,8 +193,9 @@ The gem still works as a pure HTTP client library without AMQP, exactly as befor
 | `faraday` >= 2.0 | HTTP client for Ollama REST API |
 | `lex-s3` >= 0.2 | S3 model distribution operations |
 
-Fleet transport requires Legion runtime gems (`legion-transport`, `LegionIO`) but those are *not*
-gemspec dependencies — they are expected to be present in the runtime environment.
+Fleet transport requires Legion runtime gems (`legion-transport`, `legion-llm`, `LegionIO`) but
+those are *not* gemspec dependencies — they are expected to be present in the runtime environment.
+`legion-llm` is needed for fleet message classes (`Legion::LLM::Fleet::Request`, etc.).
 
 ---
 
@@ -175,4 +210,4 @@ bundle exec rubocop
 ---
 
 **Maintained By**: Matthew Iverson (@Esity)
-**Last Updated**: 2026-04-07
+**Last Updated**: 2026-04-08

data/lib/legion/extensions/ollama/actors/model_worker.rb

@@ -11,6 +11,8 @@ module Legion
         #
         #   legion:
         #     ollama:
+        #       fleet:
+        #         consumer_priority: 10
         #       subscriptions:
         #         - type: embed
         #           model: nomic-embed-text
@@ -43,6 +45,36 @@ module Legion
             false
           end
 
+          # prefetch(1) is required for consumer priority to work correctly:
+          # without it, a high-priority consumer can hold multiple messages while
+          # lower-priority consumers sit idle. With prefetch=1, each consumer
+          # completes one message before RabbitMQ delivers the next, and priority
+          # determines which idle consumer gets it.
+          def prefetch
+            1
+          end
+
+          # Consumer priority from settings. Tells RabbitMQ to prefer this consumer
+          # over lower-priority ones on the same queue when multiple consumers are idle.
+          # Standard scale: GPU server = 10, Mac Studio = 5, developer laptop = 1.
+          # Defaults to 0 (equal priority) if not configured.
+          def consumer_priority
+            return 0 unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:ollama, :fleet, :consumer_priority) || 0
+          end
+
+          # Subscribe options include x-priority argument so RabbitMQ can honour
+          # consumer priority when dispatching to competing consumers.
+          def subscribe_options
+            base = begin
+              super
+            rescue NoMethodError
+              {}
+            end
+            base.merge(arguments: { 'x-priority' => consumer_priority })
+          end
+
           # Override queue to return a model-scoped queue bound with the precise
           # routing key for this worker's (type, model) pair.
           def queue
@@ -50,11 +82,13 @@ module Legion
           end
 
           # Enrich every inbound message with the worker's own request_type and model
-          # so Runners::Fleet#handle_request always has them, even if the sender omitted them.
+          # so Runners::Fleet#handle_request always has them, even if the sender omitted
+          # them. Also defaults message_context to {} if absent.
           def process_message(payload, metadata, delivery_info)
             msg = super
-            msg[:request_type] ||= @request_type
-            msg[:model]        ||= @model_name
+            msg[:request_type]    ||= @request_type
+            msg[:model]           ||= @model_name
+            msg[:message_context] ||= {}
             msg
           end
 

data/lib/legion/extensions/ollama/runners/fleet.rb

@@ -7,59 +7,204 @@ module Legion
         # Fleet runner — handles inbound AMQP LLM request messages and dispatches
         # them to the appropriate Ollama::Client method based on request_type.
         #
-        # Called by Actor::ModelWorker with use_runner? = false, meaning the actor
-        # calls this module directly rather than going through Legion::Runner.
+        # Called by Actor::ModelWorker with use_runner? = false.
         module Fleet
-          module_function
-
-          # Primary entry point called by the subscription actor.
-          #
-          # @param model [String] Ollama model name, e.g. "nomic-embed-text"
-          # @param request_type [String] "chat", "embed", or "generate"
-          # @param reply_to [String, nil] routing key for the reply queue (RPC pattern)
-          # @param correlation_id [String, nil] echoed back in the reply for caller matching
-          # @param payload [Hash] remaining message keys passed through to the Ollama client
-          def handle_request(model:, request_type: 'chat', reply_to: nil,
-                             correlation_id: nil, **payload)
-            result = dispatch(model: model, request_type: request_type, **payload)
-            publish_reply(reply_to, correlation_id, result.merge(model: model)) if reply_to
-            result
-          end
+          class << self
+            # Primary entry point called by the subscription actor.
+            #
+            # @param model [String] Ollama model name, e.g. "nomic-embed-text"
+            # @param request_type [String] "chat", "embed", or "generate"
+            # @param reply_to [String, nil] routing key for the reply queue (RPC pattern)
+            # @param correlation_id [String, nil] fleet correlation ID, echoed back in reply
+            # @param message_context [Hash] tracing context — copied verbatim into the reply
+            # @param payload [Hash] remaining message keys passed to the Ollama client
+            def handle_request(model:, request_type: 'chat', reply_to: nil,
+                               correlation_id: nil, message_context: {}, **payload)
+              received_at = Time.now.utc
+
+              if payload[:stream]
+                publish_error(
+                  reply_to:        reply_to,
+                  correlation_id:  correlation_id,
+                  message_context: message_context,
+                  model:           model,
+                  request_type:    request_type,
+                  error:           {
+                    code:      'unsupported_streaming',
+                    message:   'Streaming over the fleet AMQP bus is not supported in v1',
+                    retriable: false,
+                    category:  'validation',
+                    provider:  'ollama'
+                  }
+                )
+                return { result: nil, status: 422, error: 'unsupported_streaming' }
+              end
+
+              result = dispatch(model: model, request_type: request_type, **payload)
+              returned_at = Time.now.utc
+
+              if reply_to
+                publish_reply(
+                  reply_to:        reply_to,
+                  correlation_id:  correlation_id,
+                  message_context: message_context,
+                  model:           model,
+                  request_type:    request_type,
+                  result:          result,
+                  received_at:     received_at,
+                  returned_at:     returned_at
+                )
+              end
 
-          def dispatch(model:, request_type:, **payload)
-            ollama = Legion::Extensions::Ollama::Client.new
-
-            case request_type.to_s
-            when 'embed'
-              input = payload[:input] || payload[:text]
-              ollama.embed(model: model, input: input,
-                           **payload.slice(:truncate, :options, :keep_alive, :dimensions))
-            when 'generate'
-              ollama.generate(model: model, prompt: payload[:prompt],
-                              **payload.slice(:images, :format, :options, :system, :keep_alive))
-            else
-              # 'chat' and any unrecognised type falls through to chat
-              ollama.chat(model: model, messages: payload[:messages],
-                          **payload.slice(:tools, :format, :options, :keep_alive, :think))
+              result
             end
-          rescue StandardError => e
-            { result: nil, usage: {}, status: 500, error: e.message }
-          end
 
-          def publish_reply(reply_to, correlation_id, result)
-            return unless defined?(Legion::Transport)
-
-            Transport::Messages::LlmResponse.new(
-              reply_to:       reply_to,
-              correlation_id: correlation_id,
-              **result
-            ).publish
-          rescue StandardError
-            # Never let a broken reply pipeline kill the consumer ack path.
-            nil
-          end
+            # Dispatch to the correct Ollama client method by request_type.
+            #
+            # @return [Hash] { result: body, status: code } or { result: nil, status: 500, error: msg }
+            def dispatch(model:, request_type:, **payload)
+              host   = ollama_host
+              ollama = Legion::Extensions::Ollama::Client.new(host: host)
+
+              case request_type.to_s
+              when 'embed'
+                input = payload[:input] || payload[:text]
+                ollama.embed(model: model, input: input,
+                             **payload.slice(:truncate, :options, :keep_alive, :dimensions))
+              when 'generate'
+                ollama.generate(model: model, prompt: payload[:prompt],
+                                **payload.slice(:images, :format, :options, :system, :keep_alive))
+              else
+                ollama.chat(model: model, messages: payload[:messages],
+                            **payload.slice(:tools, :format, :options, :keep_alive, :think))
+              end
+            rescue StandardError => e
+              { result: nil, usage: {}, status: 500, error: e.message }
+            end
+
+            # Publish a successful fleet response to the caller's reply_to queue.
+            # Errors are swallowed so the AMQP ack path is never blocked by a broken reply.
+            def publish_reply(reply_to:, correlation_id:, message_context:, model:,
+                              request_type:, result:, received_at:, returned_at:)
+              return unless defined?(Legion::Transport)
+
+              body   = result[:result] || {}
+              usage  = result[:usage] || {}
+              status = result[:status] || 200
+              latency_ms = ((returned_at - received_at) * 1000).round
+
+              Transport::Messages::LlmResponse.new(
+                reply_to:             reply_to,
+                fleet_correlation_id: correlation_id,
+                message_context:      message_context,
+                provider:             'ollama',
+                model:                model,
+                request_type:         request_type,
+                app_id:               'lex-ollama',
+                **build_response_body(
+                  request_type: request_type,
+                  body:         body,
+                  usage:        usage,
+                  status:       status,
+                  model:        model,
+                  latency_ms:   latency_ms,
+                  received_at:  received_at,
+                  returned_at:  returned_at
+                )
+              ).publish
+            rescue StandardError
+              nil
+            end
+
+            # Publish a fleet error to the caller's reply_to queue.
+            # Errors are swallowed so the AMQP ack path is never blocked.
+            def publish_error(reply_to:, correlation_id:, message_context:, model:,
+                              request_type:, error:)
+              return unless reply_to
+              return unless defined?(Legion::Transport)
 
-          private :dispatch, :publish_reply
+              Legion::LLM::Fleet::Error.new(
+                reply_to:             reply_to,
+                fleet_correlation_id: correlation_id,
+                message_context:      message_context,
+                provider:             'ollama',
+                model:                model,
+                request_type:         request_type,
+                app_id:               'lex-ollama',
+                error:                error,
+                worker_node:          node_identity
+              ).publish
+            rescue StandardError
+              nil
+            end
+
+            private
+
+            # Build the JSON body for a successful fleet response.
+            def build_response_body(request_type:, body:, usage:, status:, model:,
+                                    latency_ms:, received_at:, returned_at:)
+              base = {
+                routing:    {
+                  provider:   'ollama',
+                  model:      model,
+                  tier:       'fleet',
+                  strategy:   'fleet_dispatch',
+                  latency_ms: latency_ms
+                },
+                tokens:     {
+                  input:  usage[:input_tokens]  || 0,
+                  output: usage[:output_tokens] || 0,
+                  total:  (usage[:input_tokens] || 0) + (usage[:output_tokens] || 0)
+                },
+                stop:       { reason: body.is_a?(Hash) ? body['done_reason'] : nil },
+                cost:       { estimated_usd: 0.0, provider: 'ollama', model: model },
+                timestamps: {
+                  received:       received_at.iso8601(3),
+                  provider_start: received_at.iso8601(3),
+                  provider_end:   returned_at.iso8601(3),
+                  returned:       returned_at.iso8601(3)
+                },
+                audit:      {
+                  'fleet:execute' => {
+                    outcome:     status == 200 ? 'success' : 'error',
+                    duration_ms: latency_ms,
+                    timestamp:   returned_at.iso8601(3)
+                  }
+                },
+                stream:     false
+              }
+
+              case request_type.to_s
+              when 'embed'
+                base.merge(
+                  embeddings: body.is_a?(Hash) ? body['embeddings'] : body
+                )
+              when 'generate'
+                base.merge(
+                  message: { role: 'assistant', content: body.is_a?(Hash) ? body['response'] : body }
+                )
+              else
+                content = body.is_a?(Hash) ? body.dig('message', 'content') : body
+                base.merge(
+                  message: { role: 'assistant', content: content }
+                )
+              end
+            end
+
+            # Resolve the Ollama host from settings, falling back to the default.
+            def ollama_host
+              return Helpers::Client::DEFAULT_HOST unless defined?(Legion::Settings)
+
+              Legion::Settings.dig(:ollama, :host) || Helpers::Client::DEFAULT_HOST
+            end
+
+            # Resolve the local node identity for worker_node in error messages.
+            def node_identity
+              return 'unknown' unless defined?(Legion::Settings)
+
+              Legion::Settings.dig(:node, :canonical_name) || 'unknown'
+            end
+          end
         end
       end
     end

data/lib/legion/extensions/ollama/transport/exchanges/llm_request.rb

@@ -5,14 +5,10 @@ module Legion
     module Ollama
       module Transport
         module Exchanges
-          class LlmRequest < Legion::Transport::Exchange
-            def exchange_name
-              'llm.request'
-            end
-
-            def default_type
-              'topic'
-            end
+          # Thin alias that delegates exchange definition to Legion::LLM::Fleet::Exchange.
+          # This class exists solely so Ollama::Transport topology introspection has a
+          # local reference without importing legion-llm internals directly.
+          class LlmRequest < Legion::LLM::Fleet::Exchange
           end
         end
       end

data/lib/legion/extensions/ollama/transport/messages/llm_response.rb

@@ -6,30 +6,19 @@ module Legion
       module Transport
         module Messages
           # Published back to the caller's reply_to queue after a fleet request is processed.
-          # Uses the default RabbitMQ exchange (direct, empty string) with reply_to as routing key,
-          # which is standard for RPC-style reply routing.
-          class LlmResponse < Legion::Transport::Message
-            def routing_key
-              @options[:reply_to]
-            end
-
-            def exchange
-              Legion::Transport::Exchanges::Agent
-            end
-
-            def encrypt?
-              false
-            end
-
-            def message
-              {
-                correlation_id: @options[:correlation_id],
-                result:         @options[:result],
-                usage:          @options[:usage],
-                model:          @options[:model],
-                provider:       'ollama',
-                status:         @options[:status] || 200
-              }
+          #
+          # Inherits Legion::LLM::Fleet::Response which:
+          #   - sets type: 'llm.fleet.response'
+          #   - sets routing_key to @options[:reply_to]
+          #   - publishes via AMQP default exchange ('')
+          #   - propagates message_context into body and headers
+          #   - generates message_id with 'resp_' prefix
+          #
+          # This class only overrides app_id so audit records and the wire protocol
+          # correctly identify lex-ollama as the worker component.
+          class LlmResponse < Legion::LLM::Fleet::Response
+            def app_id
+              'lex-ollama'
             end
           end
         end

data/lib/legion/extensions/ollama/transport/queues/model_request.rb

@@ -11,6 +11,13 @@ module Legion
           # in the RabbitMQ management UI, e.g.:
           #   llm.request.ollama.embed.nomic-embed-text
           #   llm.request.ollama.chat.qwen3.5.27b
+          #
+          # Queue strategy:
+          #   - classic (not quorum): quorum queues cannot be auto-delete
+          #   - auto_delete: true — queue deletes when last consumer disconnects + queue empties,
+          #     enabling basic.return feedback to publishers via mandatory: true
+          #   - x-max-priority: 10 — must be a queue argument at declaration time for classic
+          #     queues; policies handle max-length and overflow externally
           class ModelRequest < Legion::Transport::Queue
             def initialize(request_type:, model:, **)
               @request_type = request_type.to_s
@@ -23,14 +30,23 @@ module Legion
             end
 
             def queue_options
-              { durable: true, arguments: { 'x-queue-type': 'quorum' } }
+              {
+                durable:     false,
+                auto_delete: true,
+                arguments:   { 'x-max-priority' => 10 }
+              }
+            end
+
+            # Disable dead-letter exchange provisioning. The base class
+            # default_options always adds x-dead-letter-exchange when
+            # dlx_enabled returns true. Fleet queues are ephemeral
+            # (auto-delete) and must not provision persistent DLX queues.
+            def dlx_enabled
+              false
             end
 
             private
 
-            # Project convention: use dots as the only word separator in routing keys
-            # so queue names stay visually consistent (dots are the AMQP topic separator).
-            # e.g. "qwen3.5:27b" → "qwen3.5.27b"
             def sanitise_model(name)
               name.to_s.tr(':', '.')
             end

data/lib/legion/extensions/ollama/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Ollama
-      VERSION = '0.3.1'
+      VERSION = '0.3.2'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-ollama
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Esity
@@ -54,9 +54,6 @@ files:
 - Gemfile
 - LICENSE
 - README.md
-- docs/plans/2026-04-01-s3-model-distribution-design.md
-- docs/plans/2026-04-01-s3-model-distribution-plan.md
-- docs/plans/2026-04-07-fleet-queue-subscription-design.md
 - lex-ollama.gemspec
 - lib/legion/extensions/ollama.rb
 - lib/legion/extensions/ollama/actors/model_worker.rb